Files

No files detected

Recent reports on same IP/ASN/Domain/Screenshot

Last 5 reports on IP: 199.36.158.100

Date	UQ / IDS / BL	URL	IP
2023-02-05 09:57:50 +0000	0 - 0 - 6	inform-01.firebaseapp.com/	199.36.158.100
2023-02-05 09:57:38 +0000	0 - 0 - 6	infopostasinfo.web.app/	199.36.158.100
2023-02-05 09:44:32 +0000	0 - 0 - 6	info-sg.firebaseapp.com/	199.36.158.100
2023-02-05 09:37:16 +0000	0 - 0 - 2	bbgyu-eb375.firebaseapp.com/	199.36.158.100
2023-02-05 09:08:12 +0000	0 - 0 - 8	hy-xi1.firebaseapp.com/	199.36.158.100

Last 5 reports on ASN: FASTLY

Date	UQ / IDS / BL	URL	IP
2023-02-05 09:57:50 +0000	0 - 0 - 6	inform-01.firebaseapp.com/	199.36.158.100
2023-02-05 09:57:38 +0000	0 - 0 - 6	infopostasinfo.web.app/	199.36.158.100
2023-02-05 09:44:32 +0000	0 - 0 - 6	info-sg.firebaseapp.com/	199.36.158.100
2023-02-05 09:37:16 +0000	0 - 0 - 2	bbgyu-eb375.firebaseapp.com/	199.36.158.100
2023-02-05 09:08:12 +0000	0 - 0 - 8	hy-xi1.firebaseapp.com/	199.36.158.100

Last 3 reports on domain: redeliver-parcel-au.firebaseapp.com

Date	UQ / IDS / BL	URL	IP
2022-10-08 16:12:03 +0000	0 - 0 - 7	redeliver-parcel-au.firebaseapp.com/	199.36.158.100
2022-09-22 22:17:04 +0000	0 - 0 - 5	redeliver-parcel-au.firebaseapp.com/	199.36.158.100
2022-09-01 06:24:47 +0000	0 - 0 - 8	redeliver-parcel-au.firebaseapp.com/	199.36.158.100

No other reports with similar screenshot

JavaScript

Executed Scripts (63)

Executed Evals (18)

/*
Copyright � 2013 Adobe Systems Incorporated.

Licensed under the Apache License, Version 2.0 (the License);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an AS IS BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

/**
 * See <a href="http://jquery.com">http://jquery.com</a>.
 * @name jquery
 * @class
 * See the jQuery Library  (<a href="http://jquery.com">http://jquery.com</a>) for full details.  This just
 * documents the function and classes that are added to jQuery by this plug-in.
 */

/**
 * See <a href="http://jquery.com">http://jquery.com</a>
 * @name fn
 * @class
 * See the jQuery Library  (<a href="http://jquery.com">http://jquery.com</a>) for full details.  This just
 * documents the function and classes that are added to jQuery by this plug-in.
 * @memberOf jquery
 */

/**
 * @fileOverview accessibleMegaMenu plugin
 *
 *<p>Licensed under the Apache License, Version 2.0 (the License)
 *<br />Copyright � 2013 Adobe Systems Incorporated.
 *<br />Project page <a href="https://github.com/adobe-accessibility/Accessible-Mega-Menu">https://github.com/adobe-accessibility/Accessible-Mega-Menu</a>
 * @version 0.1
 * @author Michael Jordan
 * @requires jquery
 */

/*jslint browser: true, devel: true, plusplus: true, nomen: true */

/*global jQuery */
(function($, window, document) {
    "use strict";

    var pluginName = "megaMenu",
        defaults = {
            uuidPrefix: "accessible-megamenu",
            // unique ID's are required to indicate aria-owns, aria-controls and aria-labelledby
            menuClass: "accessible-megamenu",
            // default css class used to define the megamenu styling
            topNavItemClass: "accessible-megamenu-top-nav-item",
            // default css class for a top-level navigation item in the megamenu
            panelClass: "accessible-megamenu-panel",
            // default css class for a megamenu panel
            panelGroupClass: "accessible-megamenu-panel-group",
            // default css class for a group of items within a megamenu panel
            hoverClass: "hover",
            // default css class for the hover state
            focusClass: "focus",
            // default css class for the focus state
            openClass: "open" // default css class for the open state

        },
        Keyboard = {
            BACKSPACE: 8,
            COMMA: 188,
            DELETE: 46,
            DOWN: 40,
            END: 35,
            ENTER: 13,
            ESCAPE: 27,
            HOME: 36,
            LEFT: 37,
            PAGE_DOWN: 34,
            PAGE_UP: 33,
            PERIOD: 190,
            RIGHT: 39,
            SPACE: 32,
            TAB: 9,
            UP: 38,
            keyMap: {
                48: "0",
                49: "1",
                50: "2",
                51: "3",
                52: "4",
                53: "5",
                54: "6",
                55: "7",
                56: "8",
                57: "9",
                59: ";",
                65: "a",
                66: "b",
                67: "c",
                68: "d",
                69: "e",
                70: "f",
                71: "g",
                72: "h",
                73: "i",
                74: "j",
                75: "k",
                76: "l",
                77: "m",
                78: "n",
                79: "o",
                80: "p",
                81: "q",
                82: "r",
                83: "s",
                84: "t",
                85: "u",
                86: "v",
                87: "w",
                88: "x",
                89: "y",
                90: "z",
                96: "0",
                97: "1",
                98: "2",
                99: "3",
                100: "4",
                101: "5",
                102: "6",
                103: "7",
                104: "8",
                105: "9",
                190: "."
            }
        };
    /**
     * @desc Creates a new accessible mega menu instance.
     * @param {jquery} element
     * @param {object} [options] Mega Menu options
     * @param {string} [options.uuidPrefix=accessible-megamenu] - Prefix for generated unique id attributes, which are required to indicate aria-owns, aria-controls and aria-labelledby
     * @param {string} [options.menuClass=accessible-megamenu] - CSS class used to define the megamenu styling
     * @param {string} [options.topNavItemClass=accessible-megamenu-top-nav-item] - CSS class for a top-level navigation item in the megamenu
     * @param {string} [options.panelClass=accessible-megamenu-panel] - CSS class for a megamenu panel
     * @param {string} [options.panelGroupClass=accessible-megamenu-panel-group] - CSS class for a group of items within a megamenu panel
     * @param {string} [options.hoverClass=hover] - CSS class for the hover state
     * @param {string} [options.focusClass=focus] - CSS class for the focus state
     * @param {string} [options.openClass=open] - CSS class for the open state
     * @constructor
     */

    function AccessibleMegaMenu(element, options) {
        this.element = element; // merge optional settings and defaults into settings

        this.settings = $.extend({}, defaults, options);
        this._defaults = defaults;
        this._name = pluginName;
        this.mouseTimeoutID = null;
        this.focusTimeoutID = null;
        this.mouseFocused = false;
        this.justFocused = false;
        this.init();
    }

    AccessibleMegaMenu.prototype = function() {
        /* private attributes and methods ------------------------ */
        var uuid = 0,
            keydownTimeoutDuration = 1000,
            keydownSearchString = "",
            isTouch = typeof window.hasOwnProperty === "function" && !!window.hasOwnProperty("ontouchstart"),
            _getPlugin,
            _addUniqueId,
            _togglePanel,
            _clickHandler,
            _clickOutsideHandler,
            _DOMAttrModifiedHandler,
            _focusInHandler,
            _focusOutHandler,
            _keyDownHandler,
            _mouseDownHandler,
            _mouseOverHandler,
            _mouseOutHandler,
            _toggleExpandedEventHandlers;
        /**
         * @name jQuery.fn.accessibleMegaMenu~_getPlugin
         * @desc Returns the parent accessibleMegaMenu instance for a given element
         * @param {jQuery} element
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _getPlugin = function _getPlugin(element) {
            return $(element).closest(':data(plugin_' + pluginName + ')').data("plugin_" + pluginName);
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_addUniqueId
         * @desc Adds a unique id and element.
         * The id string starts with the
         * string defined in settings.uuidPrefix.
         * @param {jQuery} element
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _addUniqueId = function _addUniqueId(element) {
            element = $(element);
            var settings = this.settings;

            if (!element.attr("id")) {
                element.attr("id", settings.uuidPrefix + "-" + new Date().getTime() + "-" + ++uuid);
            }
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_togglePanel
         * @desc Toggle the display of mega menu panels in response to an event.
         * The optional boolean value 'hide' forces all panels to hide.
         * @param {event} event
         * @param {Boolean} [hide] Hide all mega menu panels when true
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _togglePanel = function _togglePanel(event, hide) {
            var target = $(event.target),
                that = this,
                settings = this.settings,
                menu = this.menu,
                topli = target.closest('.' + settings.topNavItemClass),
                panel = target.hasClass(settings.panelClass) ? target : target.closest('.' + settings.panelClass),
                newfocus;

            _toggleExpandedEventHandlers.call(this, true);

            if (window.matchMedia("(min-width: 970px)").matches) {
                if (hide) {
                    topli = menu.find('.' + settings.topNavItemClass + ':visible .' + settings.openClass + ':first').closest('.' + settings.topNavItemClass);

                    if (!(topli.is(event.relatedTarget) || topli.has(event.relatedTarget).length > 0)) {
                        if ((event.type === 'mouseout' || event.type === 'focusout') && topli.has(document.activeElement).length > 0) {
                            return;
                        }

                        topli.find('[aria-expanded]').attr('aria-expanded', 'false').removeClass(settings.openClass).filter('.' + settings.panelClass).attr('aria-hidden', 'true');

                        if (event.type === 'keydown' && event.keyCode === Keyboard.ESCAPE || event.type === 'DOMAttrModified') {
                            newfocus = topli.find(':tabbable:first');
                            setTimeout(function() {
                                menu.find('[aria-expanded].' + that.settings.panelClass).off('DOMAttrModified.accessible-megamenu');
                                newfocus.focus();
                                that.justFocused = false;
                            }, 99);
                        }
                    } else if (topli.length === 0) {
                        menu.find('[aria-expanded=true]').attr('aria-expanded', 'false').removeClass(settings.openClass).filter('.' + settings.panelClass).attr('aria-hidden', 'true');
                    }
                } else {
                    clearTimeout(that.focusTimeoutID);
                    topli.siblings().find('[aria-expanded]').attr('aria-expanded', 'false').removeClass(settings.openClass).filter('.' + settings.panelClass).attr('aria-hidden', 'true');
                    topli.find('[aria-expanded]').attr('aria-expanded', 'true').addClass(settings.openClass).filter('.' + settings.panelClass).attr('aria-hidden', 'false');

                    if (event.type === 'mouseover' && target.is(':tabbable') && topli.length === 1 && panel.length === 0 && menu.has(document.activeElement).length > 0) {
                        target.focus();
                        that.justFocused = false;
                    }

                    _toggleExpandedEventHandlers.call(that);
                }
            }
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_clickHandler
         * @desc Handle click event on mega menu item
         * @param {event} Event object
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _clickHandler = function _clickHandler(event) {
            var target = $(event.currentTarget),
                topli = target.closest('.' + this.settings.topNavItemClass),
                panel = target.closest('.' + this.settings.panelClass);

            if (topli.length === 1 && panel.length === 0 && topli.find('.' + this.settings.panelClass).length === 1) {
                if (!target.hasClass(this.settings.openClass)) {
                    event.preventDefault();
                    event.stopPropagation();

                    _togglePanel.call(this, event);

                    this.justFocused = false;
                } else {
                    if (this.justFocused) {
                        event.preventDefault();
                        event.stopPropagation();
                        this.justFocused = false;
                    } else if (isTouch) {
                        event.preventDefault();
                        event.stopPropagation();

                        _togglePanel.call(this, event, target.hasClass(this.settings.openClass));
                    }
                }
            }
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_clickOutsideHandler
         * @desc Handle click event outside of a the megamenu
         * @param {event} Event object
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _clickOutsideHandler = function _clickOutsideHandler(event) {
            if ($(event.target).closest(this.menu).length === 0) {
                event.preventDefault();
                event.stopPropagation();

                _togglePanel.call(this, event, true);
            }
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_DOMAttrModifiedHandler
         * @desc Handle DOMAttrModified event on panel to respond to Windows 8 Narrator ExpandCollapse pattern
         * @param {event} Event object
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _DOMAttrModifiedHandler = function _DOMAttrModifiedHandler(event) {
            if (event.originalEvent.attrName === 'aria-expanded' && event.originalEvent.newValue === 'false' && $(event.target).hasClass(this.settings.openClass)) {
                event.preventDefault();
                event.stopPropagation();

                _togglePanel.call(this, event, true);
            }
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_focusInHandler
         * @desc Handle focusin event on mega menu item.
         * @param {event} Event object
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _focusInHandler = function _focusInHandler(event) {
            clearTimeout(this.focusTimeoutID);
            var target = $(event.target),
                panel = target.closest('.' + this.settings.panelClass);
            target.addClass(this.settings.focusClass).on('click.accessible-megamenu', $.proxy(_clickHandler, this));
            this.justFocused = !this.mouseFocused;
            this.mouseFocused = false;

            if (this.panels.not(panel).filter('.' + this.settings.openClass).length) {
                _togglePanel.call(this, event);
            }
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_focusOutHandler
         * @desc Handle focusout event on mega menu item.
         * @param {event} Event object
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _focusOutHandler = function _focusOutHandler(event) {
            this.justFocused = false;
            var that = this,
                target = $(event.target),
                topli = target.closest('.' + this.settings.topNavItemClass),
                keepOpen = false;
            target.removeClass(this.settings.focusClass).off('click.accessible-megamenu');

            if (window.cvox) {
                // If ChromeVox is running...
                that.focusTimeoutID = setTimeout(function() {
                    window.cvox.Api.getCurrentNode(function(node) {
                        if (topli.has(node).length) {
                            // and the current node being voiced is in
                            // the mega menu, clearTimeout,
                            // so the panel stays open.
                            clearTimeout(that.focusTimeoutID);
                        } else {
                            that.focusTimeoutID = setTimeout(function(scope, event, hide) {
                                _togglePanel.call(scope, event, hide);
                            }, 275, that, event, true);
                        }
                    });
                }, 25);
            } else {
                that.focusTimeoutID = setTimeout(function() {
                    _togglePanel.call(that, event, true);
                }, 300);
            }
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_keyDownHandler
         * @desc Handle keydown event on mega menu.
         * @param {event} Event object
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _keyDownHandler = function _keyDownHandler(event) {
            var that = this.constructor === AccessibleMegaMenu ? this : _getPlugin(this),
                // determine the AccessibleMegaMenu plugin instance
                settings = that.settings,
                target = $($(this).is('.' + settings.hoverClass + ':tabbable') ? this : event.target),
                // if the element is hovered the target is this, otherwise, its the focused element
                menu = that.menu,
                topnavitems = that.topnavitems,
                topli = target.closest('.' + settings.topNavItemClass),
                tabbables = menu.find(':tabbable'),
                panel = target.hasClass(settings.panelClass) ? target : target.closest('.' + settings.panelClass),
                panelGroups = panel.find('.' + settings.panelGroupClass),
                currentPanelGroup = target.closest('.' + settings.panelGroupClass),
                next,
                keycode = event.keyCode || event.which,
                start,
                i,
                o,
                label,
                found = false,
                newString = Keyboard.keyMap[event.keyCode] || '',
                regex,
                isTopNavItem = topli.length === 1 && panel.length === 0;

            if (target.is("input:focus, select:focus, textarea:focus, button:focus")) {
                // if the event target is a form element we should handle keydown normally
                return;
            }

            if (target.is('.' + settings.hoverClass + ':tabbable')) {
                $('html').off('keydown.accessible-megamenu');
            }

            switch (keycode) {
                case Keyboard.ESCAPE:
                    _togglePanel.call(that, event, true);

                    break;

                case Keyboard.DOWN:
                    event.preventDefault();

                    if (isTopNavItem) {
                        _togglePanel.call(that, event);

                        found = topli.find('.' + settings.panelClass + ' :tabbable:first').focus().length === 1;
                    } else {
                        found = tabbables.filter(':gt(' + tabbables.index(target) + '):first').focus().length === 1;
                    }

                    if (!found && window.opera && opera.toString() === "[object Opera]" && (event.ctrlKey || event.metaKey)) {
                        tabbables = $(':tabbable');
                        i = tabbables.index(target);
                        found = $(':tabbable:gt(' + $(':tabbable').index(target) + '):first').focus().length === 1;
                    }

                    break;

                case Keyboard.UP:
                    event.preventDefault();

                    if (isTopNavItem && target.hasClass(settings.openClass)) {
                        _togglePanel.call(that, event, true);

                        next = topnavitems.filter(':lt(' + topnavitems.index(topli) + '):last');

                        if (next.children('.' + settings.panelClass).length) {
                            found = next.children().attr('aria-expanded', 'true').addClass(settings.openClass).filter('.' + settings.panelClass).attr('aria-hidden', 'false').find(':tabbable:last').focus() === 1;
                        }
                    } else if (!isTopNavItem) {
                        found = tabbables.filter(':lt(' + tabbables.index(target) + '):last').focus().length === 1;
                    }

                    if (!found && window.opera && opera.toString() === "[object Opera]" && (event.ctrlKey || event.metaKey)) {
                        tabbables = $(':tabbable');
                        i = tabbables.index(target);
                        found = $(':tabbable:lt(' + $(':tabbable').index(target) + '):first').focus().length === 1;
                    }

                    break;

                case Keyboard.RIGHT:
                    event.preventDefault();

                    if (isTopNavItem) {
                        found = topnavitems.filter(':gt(' + topnavitems.index(topli) + '):first').find(':tabbable:first').focus().length === 1;
                    } else {
                        if (panelGroups.length && currentPanelGroup.length) {
                            // if the current panel contains panel groups, and we are able to focus the first tabbable element of the next panel group
                            found = panelGroups.filter(':gt(' + panelGroups.index(currentPanelGroup) + '):first').find(':tabbable:first').focus().length === 1;
                        }

                        if (!found) {
                            found = topli.find(':tabbable:first').focus().length === 1;
                        }
                    }

                    break;

                case Keyboard.LEFT:
                    event.preventDefault();

                    if (isTopNavItem) {
                        found = topnavitems.filter(':lt(' + topnavitems.index(topli) + '):last').find(':tabbable:first').focus().length === 1;
                    } else {
                        if (panelGroups.length && currentPanelGroup.length) {
                            // if the current panel contains panel groups, and we are able to focus the first tabbable element of the previous panel group
                            found = panelGroups.filter(':lt(' + panelGroups.index(currentPanelGroup) + '):last').find(':tabbable:first').focus().length === 1;
                        }

                        if (!found) {
                            found = topli.find(':tabbable:first').focus().length === 1;
                        }
                    }

                    break;

                case Keyboard.TAB:
                    i = tabbables.index(target);

                    if (event.shiftKey && isTopNavItem && target.hasClass(settings.openClass)) {
                        _togglePanel.call(that, event, true);

                        next = topnavitems.filter(':lt(' + topnavitems.index(topli) + '):last');

                        if (next.children('.' + settings.panelClass).length) {
                            found = next.children().attr('aria-expanded', 'true').addClass(settings.openClass).filter('.' + settings.panelClass).attr('aria-hidden', 'false').find(':tabbable:last').focus();
                        }
                    } else if (event.shiftKey && i > 0) {
                        found = tabbables.filter(':lt(' + i + '):last').focus().length === 1;
                    } else if (!event.shiftKey && i < tabbables.length - 1) {
                        found = tabbables.filter(':gt(' + i + '):first').focus().length === 1;
                    } else if (window.opera && opera.toString() === "[object Opera]") {
                        tabbables = $(':tabbable');
                        i = tabbables.index(target);

                        if (event.shiftKey) {
                            found = $(':tabbable:lt(' + $(':tabbable').index(target) + '):last').focus().length === 1;
                        } else {
                            found = $(':tabbable:gt(' + $(':tabbable').index(target) + '):first').focus().length === 1;
                        }
                    }

                    if (found) {
                        event.preventDefault();
                    }

                    break;

                case Keyboard.SPACE:
                    if (isTopNavItem) {
                        event.preventDefault();

                        _clickHandler.call(that, event);
                    } else {
                        return true;
                    }

                    break;

                case Keyboard.ENTER:
                    return true;
                    break;

                default:
                    // alphanumeric filter
                    clearTimeout(this.keydownTimeoutID);
                    keydownSearchString += newString !== keydownSearchString ? newString : '';

                    if (keydownSearchString.length === 0) {
                        return;
                    }

                    this.keydownTimeoutID = setTimeout(function() {
                        keydownSearchString = '';
                    }, keydownTimeoutDuration);

                    if (isTopNavItem && !target.hasClass(settings.openClass)) {
                        tabbables = tabbables.filter(':not(.' + settings.panelClass + ' :tabbable)');
                    } else {
                        tabbables = topli.find(':tabbable');
                    }

                    if (event.shiftKey) {
                        tabbables = $(tabbables.get().reverse());
                    }

                    for (i = 0; i < tabbables.length; i++) {
                        o = tabbables.eq(i);

                        if (o.is(target)) {
                            start = keydownSearchString.length === 1 ? i + 1 : i;
                            break;
                        }
                    }

                    regex = new RegExp('^' + keydownSearchString.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&'), 'i');

                    for (i = start; i < tabbables.length; i++) {
                        o = tabbables.eq(i);
                        label = $.trim(o.text());

                        if (regex.test(label)) {
                            found = true;
                            o.focus();
                            break;
                        }
                    }

                    if (!found) {
                        for (i = 0; i < start; i++) {
                            o = tabbables.eq(i);
                            label = $.trim(o.text());

                            if (regex.test(label)) {
                                o.focus();
                                break;
                            }
                        }
                    }

                    break;
            }

            that.justFocused = false;
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_mouseDownHandler
         * @desc Handle mousedown event on mega menu.
         * @param {event} Event object
         * @memberof accessibleMegaMenu
         * @inner
         * @private
         */


        _mouseDownHandler = function _mouseDownHandler(event) {
            if ($(event.target).is(this.settings.panelClass) || $(event.target).closest(":focusable").length) {
                this.mouseFocused = true;
            }

            this.mouseTimeoutID = setTimeout(function() {
                clearTimeout(this.focusTimeoutID);
            }, 1);
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_mouseOverHandler
         * @desc Handle mouseover event on mega menu.
         * @param {event} Event object
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _mouseOverHandler = function _mouseOverHandler(event) {
            clearTimeout(this.mouseTimeoutID);
            $(event.target).addClass(this.settings.hoverClass);

            _togglePanel.call(this, event);

            if ($(event.target).is(':tabbable')) {
                $('html').on('keydown.accessible-megamenu', $.proxy(_keyDownHandler, event.target));
            }
        };
        /**
         * @name jQuery.fn.accessibleMegaMenu~_mouseOutHandler
         * @desc Handle mouseout event on mega menu.
         * @param {event} Event object
         * @memberof jQuery.fn.accessibleMegaMenu
         * @inner
         * @private
         */


        _mouseOutHandler = function _mouseOutHandler(event) {
            var that = this;
            $(event.target).removeClass(that.settings.hoverClass);
            that.mouseTimeoutID = setTimeout(function() {
                _togglePanel.call(that, event, true);
            }, 250);

            if ($(event.target).is(':tabbable')) {
                $('html').off('keydown.accessible-megamenu');
            }
        };

        _toggleExpandedEventHandlers = function _toggleExpandedEventHandlers(hide) {
            var menu = this.menu;

            if (hide) {
                $('html').off('mouseup.outside-accessible-megamenu, touchend.outside-accessible-megamenu, mspointerup.outside-accessible-megamenu,  pointerup.outside-accessible-megamenu');
                menu.find('[aria-expanded].' + this.settings.panelClass).off('DOMAttrModified.accessible-megamenu');
            } else {
                $('html').on('mouseup.outside-accessible-megamenu, touchend.outside-accessible-megamenu, mspointerup.outside-accessible-megamenu,  pointerup.outside-accessible-megamenu', $.proxy(_clickOutsideHandler, this));
                /* Narrator in Windows 8 automatically toggles the aria-expanded property on double tap or click.
                   To respond to the change to collapse the panel, we must add a listener for a DOMAttrModified event. */

                menu.find('[aria-expanded=true].' + this.settings.panelClass).on('DOMAttrModified.accessible-megamenu', $.proxy(_DOMAttrModifiedHandler, this));
            }
        };
        /* public attributes and methods ------------------------- */


        return {
            constructor: AccessibleMegaMenu,

            /**
             * @lends jQuery.fn.accessibleMegaMenu
             * @desc Initializes an instance of the accessibleMegaMenu plugins
             * @memberof jQuery.fn.accessibleMegaMenu
             * @instance
             */
            init: function init() {
                var settings = this.settings,
                    nav = $(this.element),
                    menu = nav.children('ul').first(),
                    topnavitems = menu.children();
                this.start(settings, nav, menu, topnavitems);
            },
            start: function start(settings, nav, menu, topnavitems) {
                var that = this;
                var CLASS_PRIMARY_TOOLS_LIST = 'pn-link--tools';
                var CLASS_PRIMARY_UTILITY_LIST = 'pn-link--utility';
                this.settings = settings;
                this.menu = menu;
                this.topnavitems = topnavitems;
                nav.attr("role", "navigation");
                menu.addClass(settings.menuClass);
                topnavitems.each(function(i, topnavitem) {
                    var topnavitemlink, topnavitempanel;
                    topnavitem = $(topnavitem);
                    topnavitem.addClass(settings.topNavItemClass);
                    topnavitemlink = topnavitem.find(":tabbable:first");
                    topnavitempanel = topnavitem.children(":not(:tabbable):last");

                    _addUniqueId.call(that, topnavitemlink);

                    if (topnavitempanel.length) {
                        _addUniqueId.call(that, topnavitempanel);

                        if (!topnavitempanel.hasClass('is-open')) {
                            //DTN-1565: Tools and Utility has no collapse/expand
                            if (!(topnavitemlink.hasClass(CLASS_PRIMARY_TOOLS_LIST) || topnavitemlink.hasClass(CLASS_PRIMARY_UTILITY_LIST))) {
                                topnavitemlink.attr({
                                    "aria-expanded": false
                                });
                            }
                        } // only set aria-expanded and aria-hidden for panel that is not open.
                        // 'is-open' attribute is set on the aem sightly template (primary-nav.html)
                        // e.g. if we're on a page that is under Business, then dom for business panel is 'is-open'


                        if (!topnavitempanel.hasClass('is-open')) {
                            topnavitempanel.attr({
                                "role": "group",
                                "aria-expanded": false,
                                "aria-hidden": true
                            }).addClass(settings.panelClass);
                        }
                    }
                });
                this.panels = menu.find("." + settings.panelClass);
                menu.on("focusin.accessible-megamenu", ":focusable, ." + settings.panelClass, $.proxy(_focusInHandler, this)).on("focusout.accessible-megamenu", ":focusable, ." + settings.panelClass, $.proxy(_focusOutHandler, this)).on("keydown.accessible-megamenu", $.proxy(_keyDownHandler, this)).on("mouseover.accessible-megamenu", $.proxy(_mouseOverHandler, this)).on("mouseout.accessible-megamenu", $.proxy(_mouseOutHandler, this)).on("mousedown.accessible-megamenu", $.proxy(_mouseDownHandler, this));

                if (isTouch) {
                    menu.on("touchstart.accessible-megamenu", $.proxy(_clickHandler, this));
                }

                menu.find("hr").attr("role", "separator");

                if ($(document.activeElement).closest(menu).length) {
                    $(document.activeElement).trigger("focusin.accessible-megamenu");
                }
            },

            /**
             * @desc Get default values
             * @example $(selector).accessibleMegaMenu("getDefaults");
             * @return {object}
             * @memberof jQuery.fn.accessibleMegaMenu
             * @instance
             */
            getDefaults: function getDefaults() {
                return this._defaults;
            },

            /**
             * @desc Get any option set to plugin using its name (as string)
             * @example $(selector).accessibleMegaMenu("getOption", some_option);
             * @param {string} opt
             * @return {string}
             * @memberof jQuery.fn.accessibleMegaMenu
             * @instance
             */
            getOption: function getOption(opt) {
                return this.settings[opt];
            },

            /**
             * @desc Get all options
             * @example $(selector).accessibleMegaMenu("getAllOptions");
             * @return {object}
             * @memberof jQuery.fn.accessibleMegaMenu
             * @instance
             */
            getAllOptions: function getAllOptions() {
                return this.settings;
            },

            /**
             * @desc Set option
             * @example $(selector).accessibleMegaMenu("setOption", "option_name",  "option_value",  reinitialize);
             * @param {string} opt - Option name
             * @param {string} val - Option value
             * @param {boolean} [reinitialize] - boolean to re-initialize the menu.
             * @memberof jQuery.fn.accessibleMegaMenu
             * @instance
             */
            setOption: function setOption(opt, value, reinitialize) {
                this.settings[opt] = value;

                if (reinitialize) {
                    this.init();
                }
            }
        };
    }();

    $.fn[pluginName] = function(options) {
        return this.each(function() {
            if (!$.data(this, "plugin_" + pluginName)) {
                $.data(this, "plugin_" + pluginName, new $.fn[pluginName].AccessibleMegaMenu(this, options));
            }
        });
    };

    $.fn[pluginName].AccessibleMegaMenu = AccessibleMegaMenu;
    /**
     * @private
     */

    function visible(element) {
            return $.expr.filters.visible(element) && !$(element).parents().addBack().filter(function() {
                return $.css(this, "visibility") === "hidden";
            }).length;
        }
        /**
         * @private
         */


    function _focusable(element, isTabIndexNotNaN) {
        var map,
            mapName,
            img,
            nodeName = element.nodeName.toLowerCase();

        if ("area" === nodeName) {
            map = element.parentNode;
            mapName = map.name;

            if (!element.href || !mapName || map.nodeName.toLowerCase() !== "map") {
                return false;
            }

            img = $("img[usemap=#" + mapName + "]")[0];
            return !!img && visible(img);
        }

        return (/input|select|textarea|button|object/.test(nodeName) ? !element.disabled : "a" === nodeName ? element.href || isTabIndexNotNaN : isTabIndexNotNaN) && // the element and all of its ancestors must be visible
            visible(element);
    }

    $.extend($.expr[":"], {
        data: $.expr.createPseudo ? $.expr.createPseudo(function(dataName) {
                return function(elem) {
                    return !!$.data(elem, dataName);
                };
            }) : // support: jQuery <1.8
            function(elem, i, match) {
                return !!$.data(elem, match[3]);
            },
        focusable: function focusable(element) {
            return _focusable(element, !isNaN($.attr(element, "tabindex")));
        },
        tabbable: function tabbable(element) {
            var tabIndex = $.attr(element, "tabindex"),
                isTabIndexNaN = isNaN(tabIndex);
            return (isTabIndexNaN || tabIndex >= 0) && _focusable(element, !isTabIndexNaN);
        }
    });
})(jQuery, window, document); //# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"115.js","names":["$","window","document","pluginName","defaults","uuidPrefix","menuClass","topNavItemClass","panelClass","panelGroupClass","hoverClass","focusClass","openClass","Keyboard","BACKSPACE","COMMA","DELETE","DOWN","END","ENTER","ESCAPE","HOME","LEFT","PAGE_DOWN","PAGE_UP","PERIOD","RIGHT","SPACE","TAB","UP","keyMap","AccessibleMegaMenu","element","options","settings","extend","_defaults","_name","mouseTimeoutID","focusTimeoutID","mouseFocused","justFocused","init","prototype","uuid","keydownTimeoutDuration","keydownSearchString","isTouch","hasOwnProperty","_getPlugin","_addUniqueId","_togglePanel","_clickHandler","_clickOutsideHandler","_DOMAttrModifiedHandler","_focusInHandler","_focusOutHandler","_keyDownHandler","_mouseDownHandler","_mouseOverHandler","_mouseOutHandler","_toggleExpandedEventHandlers","closest","data","attr","Date","getTime","event","hide","target","that","menu","topli","panel","hasClass","newfocus","call","matchMedia","matches","find","is","relatedTarget","has","length","type","activeElement","removeClass","filter","keyCode","setTimeout","off","focus","clearTimeout","siblings","addClass","currentTarget","preventDefault","stopPropagation","originalEvent","attrName","newValue","on","proxy","panels","not","keepOpen","cvox","Api","getCurrentNode","node","scope","constructor","topnavitems","tabbables","panelGroups","currentPanelGroup","next","keycode","which","start","i","o","label","found","newString","regex","isTopNavItem","index","opera","toString","ctrlKey","metaKey","children","shiftKey","keydownTimeoutID","get","reverse","eq","RegExp","replace","trim","text","test","nav","first","CLASS_PRIMARY_TOOLS_LIST","CLASS_PRIMARY_UTILITY_LIST","each","topnavitem","topnavitemlink","topnavitempanel","trigger","getDefaults","getOption","opt","getAllOptions","setOption","value","reinitialize","fn","visible","expr","filters","parents","addBack","css","focusable","isTabIndexNotNaN","map","mapName","img","nodeName","toLowerCase","parentNode","name","href","disabled","createPseudo","dataName","elem","match","isNaN","tabbable","tabIndex","isTabIndexNaN","jQuery"],"sourceRoot":"","sources":["webpack://aem-cms-code/./ui.frontend/src/main/global/js/vendors/megamenu.js?db46"],"sourcesContent":["/*\nCopyright © 2013 Adobe Systems Incorporated.\n\nLicensed under the Apache License, Version 2.0 (the “License”);\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an “AS IS” BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * See <a href=\"http://jquery.com\">http://jquery.com</a>.\n * @name jquery\n * @class\n * See the jQuery Library  (<a href=\"http://jquery.com\">http://jquery.com</a>) for full details.  This just\n * documents the function and classes that are added to jQuery by this plug-in.\n */\n\n/**\n * See <a href=\"http://jquery.com\">http://jquery.com</a>\n * @name fn\n * @class\n * See the jQuery Library  (<a href=\"http://jquery.com\">http://jquery.com</a>) for full details.  This just\n * documents the function and classes that are added to jQuery by this plug-in.\n * @memberOf jquery\n */\n\n/**\n * @fileOverview accessibleMegaMenu plugin\n *\n *<p>Licensed under the Apache License, Version 2.0 (the “License”)\n *<br />Copyright © 2013 Adobe Systems Incorporated.\n *<br />Project page <a href=\"https://github.com/adobe-accessibility/Accessible-Mega-Menu\">https://github.com/adobe-accessibility/Accessible-Mega-Menu</a>\n * @version 0.1\n * @author Michael Jordan\n * @requires jquery\n */\n\n/*jslint browser: true, devel: true, plusplus: true, nomen: true */\n/*global jQuery */\n(function ($, window, document) {\n\n    \"use strict\";\n\n    var pluginName = \"megaMenu\",\n        defaults = {\n            uuidPrefix: \"accessible-megamenu\", // unique ID's are required to indicate aria-owns, aria-controls and aria-labelledby\n            menuClass: \"accessible-megamenu\", // default css class used to define the megamenu styling\n            topNavItemClass: \"accessible-megamenu-top-nav-item\", // default css class for a top-level navigation item in the megamenu\n            panelClass: \"accessible-megamenu-panel\", // default css class for a megamenu panel\n            panelGroupClass: \"accessible-megamenu-panel-group\", // default css class for a group of items within a megamenu panel\n            hoverClass: \"hover\", // default css class for the hover state\n            focusClass: \"focus\", // default css class for the focus state\n            openClass: \"open\" // default css class for the open state\n        },\n        Keyboard = {\n            BACKSPACE: 8,\n            COMMA: 188,\n            DELETE: 46,\n            DOWN: 40,\n            END: 35,\n            ENTER: 13,\n            ESCAPE: 27,\n            HOME: 36,\n            LEFT: 37,\n            PAGE_DOWN: 34,\n            PAGE_UP: 33,\n            PERIOD: 190,\n            RIGHT: 39,\n            SPACE: 32,\n            TAB: 9,\n            UP: 38,\n            keyMap: {\n                48: \"0\",\n                49: \"1\",\n                50: \"2\",\n                51: \"3\",\n                52: \"4\",\n                53: \"5\",\n                54: \"6\",\n                55: \"7\",\n                56: \"8\",\n                57: \"9\",\n                59: \";\",\n                65: \"a\",\n                66: \"b\",\n                67: \"c\",\n                68: \"d\",\n                69: \"e\",\n                70: \"f\",\n                71: \"g\",\n                72: \"h\",\n                73: \"i\",\n                74: \"j\",\n                75: \"k\",\n                76: \"l\",\n                77: \"m\",\n                78: \"n\",\n                79: \"o\",\n                80: \"p\",\n                81: \"q\",\n                82: \"r\",\n                83: \"s\",\n                84: \"t\",\n                85: \"u\",\n                86: \"v\",\n                87: \"w\",\n                88: \"x\",\n                89: \"y\",\n                90: \"z\",\n                96: \"0\",\n                97: \"1\",\n                98: \"2\",\n                99: \"3\",\n                100: \"4\",\n                101: \"5\",\n                102: \"6\",\n                103: \"7\",\n                104: \"8\",\n                105: \"9\",\n                190: \".\"\n            }\n        };\n    /**\n     * @desc Creates a new accessible mega menu instance.\n     * @param {jquery} element\n     * @param {object} [options] Mega Menu options\n     * @param {string} [options.uuidPrefix=accessible-megamenu] - Prefix for generated unique id attributes, which are required to indicate aria-owns, aria-controls and aria-labelledby\n     * @param {string} [options.menuClass=accessible-megamenu] - CSS class used to define the megamenu styling\n     * @param {string} [options.topNavItemClass=accessible-megamenu-top-nav-item] - CSS class for a top-level navigation item in the megamenu\n     * @param {string} [options.panelClass=accessible-megamenu-panel] - CSS class for a megamenu panel\n     * @param {string} [options.panelGroupClass=accessible-megamenu-panel-group] - CSS class for a group of items within a megamenu panel\n     * @param {string} [options.hoverClass=hover] - CSS class for the hover state\n     * @param {string} [options.focusClass=focus] - CSS class for the focus state\n     * @param {string} [options.openClass=open] - CSS class for the open state\n     * @constructor\n     */\n    function AccessibleMegaMenu(element, options) {\n        this.element = element;\n\n        // merge optional settings and defaults into settings\n        this.settings = $.extend({}, defaults, options);\n\n        this._defaults = defaults;\n        this._name = pluginName;\n\n        this.mouseTimeoutID = null;\n        this.focusTimeoutID = null;\n        this.mouseFocused = false;\n        this.justFocused = false;\n\n        this.init();\n    }\n\n    AccessibleMegaMenu.prototype = (function () {\n\n        /* private attributes and methods ------------------------ */\n        var uuid = 0,\n            keydownTimeoutDuration = 1000,\n            keydownSearchString = \"\",\n            isTouch = typeof window.hasOwnProperty === \"function\" && !!window.hasOwnProperty(\"ontouchstart\"),\n            _getPlugin,\n            _addUniqueId,\n            _togglePanel,\n            _clickHandler,\n            _clickOutsideHandler,\n            _DOMAttrModifiedHandler,\n            _focusInHandler,\n            _focusOutHandler,\n            _keyDownHandler,\n            _mouseDownHandler,\n            _mouseOverHandler,\n            _mouseOutHandler,\n            _toggleExpandedEventHandlers;\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_getPlugin\n         * @desc Returns the parent accessibleMegaMenu instance for a given element\n         * @param {jQuery} element\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _getPlugin = function (element) {\n            return $(element).closest(':data(plugin_' + pluginName + ')').data(\"plugin_\" + pluginName);\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_addUniqueId\n         * @desc Adds a unique id and element.\n         * The id string starts with the\n         * string defined in settings.uuidPrefix.\n         * @param {jQuery} element\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _addUniqueId = function (element) {\n            element = $(element);\n            var settings = this.settings;\n            if (!element.attr(\"id\")) {\n                element.attr(\"id\", settings.uuidPrefix + \"-\" + new Date().getTime() + \"-\" + (++uuid));\n            }\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_togglePanel\n         * @desc Toggle the display of mega menu panels in response to an event.\n         * The optional boolean value 'hide' forces all panels to hide.\n         * @param {event} event\n         * @param {Boolean} [hide] Hide all mega menu panels when true\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _togglePanel = function (event, hide) {\n            var target = $(event.target),\n                that = this,\n                settings = this.settings,\n                menu = this.menu,\n                topli = target.closest('.' + settings.topNavItemClass),\n                panel = target.hasClass(settings.panelClass) ? target : target.closest('.' + settings.panelClass),\n                newfocus;\n\n            _toggleExpandedEventHandlers.call(this, true);\n            if (window.matchMedia(\"(min-width: 970px)\").matches) {\n                if (hide) {\n                    topli = menu.find('.' + settings.topNavItemClass + ':visible .' + settings.openClass + ':first').closest('.' + settings.topNavItemClass);\n                    if (!(topli.is(event.relatedTarget) || topli.has(event.relatedTarget).length > 0)) {\n                        if ((event.type === 'mouseout' || event.type === 'focusout') && topli.has(document.activeElement).length > 0) {\n                            return;\n                        }\n                        topli.find('[aria-expanded]')\n                            .attr('aria-expanded', 'false')\n                            .removeClass(settings.openClass)\n                            .filter('.' + settings.panelClass)\n                            .attr('aria-hidden', 'true');\n                        if ((event.type === 'keydown' && event.keyCode === Keyboard.ESCAPE) || event.type === 'DOMAttrModified') {\n                            newfocus = topli.find(':tabbable:first');\n                            setTimeout(function () {\n                                menu.find('[aria-expanded].' + that.settings.panelClass).off('DOMAttrModified.accessible-megamenu');\n                                newfocus.focus();\n                                that.justFocused = false;\n                            }, 99);\n                        }\n                    } else if (topli.length === 0) {\n                        menu.find('[aria-expanded=true]')\n                            .attr('aria-expanded', 'false')\n                            .removeClass(settings.openClass)\n                            .filter('.' + settings.panelClass)\n                            .attr('aria-hidden', 'true');\n                    }\n                } else {\n                    clearTimeout(that.focusTimeoutID);\n                    topli.siblings()\n                        .find('[aria-expanded]')\n                        .attr('aria-expanded', 'false')\n                        .removeClass(settings.openClass)\n                        .filter('.' + settings.panelClass)\n                        .attr('aria-hidden', 'true');\n                    topli.find('[aria-expanded]')\n                        .attr('aria-expanded', 'true')\n                        .addClass(settings.openClass)\n                        .filter('.' + settings.panelClass)\n                        .attr('aria-hidden', 'false');\n                    if (event.type === 'mouseover' && target.is(':tabbable') && topli.length === 1 && panel.length === 0 && menu.has(document.activeElement).length > 0) {\n                        target.focus();\n                        that.justFocused = false;\n                    }\n\n                    _toggleExpandedEventHandlers.call(that);\n                }\n        }\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_clickHandler\n         * @desc Handle click event on mega menu item\n         * @param {event} Event object\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _clickHandler = function (event) {\n            var target = $(event.currentTarget),\n                topli = target.closest('.' + this.settings.topNavItemClass),\n                panel = target.closest('.' + this.settings.panelClass);\n            if (topli.length === 1\n                    && panel.length === 0\n                    && topli.find('.' + this.settings.panelClass).length === 1) {\n                if (!target.hasClass(this.settings.openClass)) {\n                    event.preventDefault();\n                    event.stopPropagation();\n                    _togglePanel.call(this, event);\n                    this.justFocused = false;\n                } else {\n                    if (this.justFocused) {\n                        event.preventDefault();\n                        event.stopPropagation();\n                        this.justFocused = false;\n                    } else if (isTouch) {\n                        event.preventDefault();\n                        event.stopPropagation();\n                        _togglePanel.call(this, event, target.hasClass(this.settings.openClass));\n                    }\n                }\n            }\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_clickOutsideHandler\n         * @desc Handle click event outside of a the megamenu\n         * @param {event} Event object\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _clickOutsideHandler = function (event) {\n            if ($(event.target).closest(this.menu).length === 0) {\n                event.preventDefault();\n                event.stopPropagation();\n                _togglePanel.call(this, event, true);\n            }\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_DOMAttrModifiedHandler\n         * @desc Handle DOMAttrModified event on panel to respond to Windows 8 Narrator ExpandCollapse pattern\n         * @param {event} Event object\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _DOMAttrModifiedHandler = function (event) {\n            if (event.originalEvent.attrName === 'aria-expanded'\n                    && event.originalEvent.newValue === 'false'\n                    && $(event.target).hasClass(this.settings.openClass)) {\n                event.preventDefault();\n                event.stopPropagation();\n                _togglePanel.call(this, event, true);\n            }\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_focusInHandler\n         * @desc Handle focusin event on mega menu item.\n         * @param {event} Event object\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _focusInHandler = function (event) {\n            clearTimeout(this.focusTimeoutID);\n            var target = $(event.target),\n                panel = target.closest('.' + this.settings.panelClass);\n            target\n                .addClass(this.settings.focusClass)\n                .on('click.accessible-megamenu', $.proxy(_clickHandler, this));\n            this.justFocused = !this.mouseFocused;\n            this.mouseFocused = false;\n            if (this.panels.not(panel).filter('.' + this.settings.openClass).length) {\n                _togglePanel.call(this, event);\n            }\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_focusOutHandler\n         * @desc Handle focusout event on mega menu item.\n         * @param {event} Event object\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _focusOutHandler = function (event) {\n            this.justFocused = false;\n            var that = this,\n                target = $(event.target),\n                topli = target.closest('.' + this.settings.topNavItemClass),\n                keepOpen = false;\n            target\n                .removeClass(this.settings.focusClass)\n                .off('click.accessible-megamenu');\n\n            if (window.cvox) {\n                // If ChromeVox is running...\n                that.focusTimeoutID = setTimeout(function () {\n                    window.cvox.Api.getCurrentNode(function (node) {\n                        if (topli.has(node).length) {\n                            // and the current node being voiced is in\n                            // the mega menu, clearTimeout,\n                            // so the panel stays open.\n                            clearTimeout(that.focusTimeoutID);\n                        } else {\n                            that.focusTimeoutID = setTimeout(function (scope, event, hide) {\n                                _togglePanel.call(scope, event, hide);\n                            }, 275, that, event, true);\n                        }\n                    });\n                }, 25);\n            } else {\n                that.focusTimeoutID = setTimeout(function () {\n                    _togglePanel.call(that, event, true);\n                }, 300);\n            }\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_keyDownHandler\n         * @desc Handle keydown event on mega menu.\n         * @param {event} Event object\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _keyDownHandler = function (event) {\n            var that = (this.constructor === AccessibleMegaMenu) ? this : _getPlugin(this), // determine the AccessibleMegaMenu plugin instance\n                settings = that.settings,\n                target = $($(this).is('.' + settings.hoverClass + ':tabbable') ? this : event.target), // if the element is hovered the target is this, otherwise, its the focused element\n                menu = that.menu,\n                topnavitems = that.topnavitems,\n                topli = target.closest('.' + settings.topNavItemClass),\n                tabbables = menu.find(':tabbable'),\n                panel = target.hasClass(settings.panelClass) ? target : target.closest('.' + settings.panelClass),\n                panelGroups = panel.find('.' + settings.panelGroupClass),\n                currentPanelGroup = target.closest('.' + settings.panelGroupClass),\n                next,\n                keycode = event.keyCode || event.which,\n                start,\n                i,\n                o,\n                label,\n                found = false,\n                newString = Keyboard.keyMap[event.keyCode] || '',\n                regex,\n                isTopNavItem = (topli.length === 1 && panel.length === 0);\n\n            if (target.is(\"input:focus, select:focus, textarea:focus, button:focus\")) {\n                // if the event target is a form element we should handle keydown normally\n                return;\n            }\n\n            if (target.is('.' + settings.hoverClass + ':tabbable')) {\n                $('html').off('keydown.accessible-megamenu');\n            }\n\n            switch (keycode) {\n            case Keyboard.ESCAPE:\n                _togglePanel.call(that, event, true);\n                break;\n            case Keyboard.DOWN:\n                event.preventDefault();\n                if (isTopNavItem) {\n                    _togglePanel.call(that, event);\n                    found = (topli.find('.' + settings.panelClass + ' :tabbable:first').focus().length === 1);\n                } else {\n                    found = (tabbables.filter(':gt(' + tabbables.index(target) + '):first').focus().length === 1);\n                }\n\n                if (!found && window.opera && opera.toString() === \"[object Opera]\" && (event.ctrlKey || event.metaKey)) {\n                    tabbables = $(':tabbable');\n                    i = tabbables.index(target);\n                    found = ($(':tabbable:gt(' + $(':tabbable').index(target) + '):first').focus().length === 1);\n                }\n                break;\n            case Keyboard.UP:\n                event.preventDefault();\n                if (isTopNavItem && target.hasClass(settings.openClass)) {\n                    _togglePanel.call(that, event, true);\n                    next = topnavitems.filter(':lt(' + topnavitems.index(topli) + '):last');\n                    if (next.children('.' + settings.panelClass).length) {\n                        found = (next.children()\n                            .attr('aria-expanded', 'true')\n                            .addClass(settings.openClass)\n                            .filter('.' + settings.panelClass)\n                            .attr('aria-hidden', 'false')\n                            .find(':tabbable:last')\n                            .focus() === 1);\n                    }\n                } else if (!isTopNavItem) {\n                    found = (tabbables.filter(':lt(' + tabbables.index(target) + '):last').focus().length === 1);\n                }\n\n                if (!found && window.opera && opera.toString() === \"[object Opera]\" && (event.ctrlKey || event.metaKey)) {\n                    tabbables = $(':tabbable');\n                    i = tabbables.index(target);\n                    found = ($(':tabbable:lt(' + $(':tabbable').index(target) + '):first').focus().length === 1);\n                }\n                break;\n            case Keyboard.RIGHT:\n                event.preventDefault();\n                if (isTopNavItem) {\n                    found = (topnavitems.filter(':gt(' + topnavitems.index(topli) + '):first').find(':tabbable:first').focus().length === 1);\n                } else {\n                    if (panelGroups.length && currentPanelGroup.length) {\n                        // if the current panel contains panel groups, and we are able to focus the first tabbable element of the next panel group\n                        found = (panelGroups.filter(':gt(' + panelGroups.index(currentPanelGroup) + '):first').find(':tabbable:first').focus().length === 1);\n                    }\n\n                    if (!found) {\n                        found = (topli.find(':tabbable:first').focus().length === 1);\n                    }\n                }\n                break;\n            case Keyboard.LEFT:\n                event.preventDefault();\n                if (isTopNavItem) {\n                    found = (topnavitems.filter(':lt(' + topnavitems.index(topli) + '):last').find(':tabbable:first').focus().length === 1);\n                } else {\n                    if (panelGroups.length && currentPanelGroup.length) {\n                        // if the current panel contains panel groups, and we are able to focus the first tabbable element of the previous panel group\n                        found = (panelGroups.filter(':lt(' + panelGroups.index(currentPanelGroup) + '):last').find(':tabbable:first').focus().length === 1);\n                    }\n\n                    if (!found) {\n                        found = (topli.find(':tabbable:first').focus().length === 1);\n                    }\n                }\n                break;\n            case Keyboard.TAB:\n                i = tabbables.index(target);\n                if (event.shiftKey && isTopNavItem && target.hasClass(settings.openClass)) {\n                    _togglePanel.call(that, event, true);\n                    next = topnavitems.filter(':lt(' + topnavitems.index(topli) + '):last');\n                    if (next.children('.' + settings.panelClass).length) {\n                        found = next.children()\n                            .attr('aria-expanded', 'true')\n                            .addClass(settings.openClass)\n                            .filter('.' + settings.panelClass)\n                            .attr('aria-hidden', 'false')\n                            .find(':tabbable:last')\n                            .focus();\n                    }\n                } else if (event.shiftKey && i > 0) {\n                    found = (tabbables.filter(':lt(' + i + '):last').focus().length === 1);\n                } else if (!event.shiftKey && i < tabbables.length - 1) {\n                    found = (tabbables.filter(':gt(' + i + '):first').focus().length === 1);\n                } else if (window.opera && opera.toString() === \"[object Opera]\") {\n                    tabbables = $(':tabbable');\n                    i = tabbables.index(target);\n                    if (event.shiftKey) {\n                        found = ($(':tabbable:lt(' + $(':tabbable').index(target) + '):last').focus().length === 1);\n                    } else {\n                        found = ($(':tabbable:gt(' + $(':tabbable').index(target) + '):first').focus().length === 1);\n                    }\n                }\n\n                if (found) {\n                    event.preventDefault();\n                }\n                break;\n            case Keyboard.SPACE:\n                if (isTopNavItem) {\n                    event.preventDefault();\n                    _clickHandler.call(that, event);\n                } else {\n                    return true;\n                }\n                break;\n            case Keyboard.ENTER:\n                return true;\n                break;\n            default:\n                // alphanumeric filter\n                clearTimeout(this.keydownTimeoutID);\n\n                keydownSearchString += newString !== keydownSearchString ? newString : '';\n\n                if (keydownSearchString.length === 0) {\n                    return;\n                }\n\n                this.keydownTimeoutID = setTimeout(function () {\n                    keydownSearchString = '';\n                }, keydownTimeoutDuration);\n\n                if (isTopNavItem && !target.hasClass(settings.openClass)) {\n                    tabbables = tabbables.filter(':not(.' + settings.panelClass + ' :tabbable)');\n                } else {\n                    tabbables = topli.find(':tabbable');\n                }\n\n                if (event.shiftKey) {\n                    tabbables = $(tabbables.get()\n                        .reverse());\n                }\n\n                for (i = 0; i < tabbables.length; i++) {\n                    o = tabbables.eq(i);\n                    if (o.is(target)) {\n                        start = (keydownSearchString.length === 1) ? i + 1 : i;\n                        break;\n                    }\n                }\n\n                regex = new RegExp('^' + keydownSearchString.replace(/[\\-\\[\\]{}()*+?.,\\\\\\^$|#\\s]/g, '\\\\$&'), 'i');\n\n                for (i = start; i < tabbables.length; i++) {\n                    o = tabbables.eq(i);\n                    label = $.trim(o.text());\n                    if (regex.test(label)) {\n                        found = true;\n                        o.focus();\n                        break;\n                    }\n                }\n                if (!found) {\n                    for (i = 0; i < start; i++) {\n                        o = tabbables.eq(i);\n                        label = $.trim(o.text());\n                        if (regex.test(label)) {\n                            o.focus();\n                            break;\n                        }\n                    }\n                }\n                break;\n            }\n            that.justFocused = false;\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_mouseDownHandler\n         * @desc Handle mousedown event on mega menu.\n         * @param {event} Event object\n         * @memberof accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _mouseDownHandler = function (event) {\n            if ($(event.target).is(this.settings.panelClass) || $(event.target).closest(\":focusable\").length) {\n                this.mouseFocused = true;\n            }\n            this.mouseTimeoutID = setTimeout(function () {\n                clearTimeout(this.focusTimeoutID);\n            }, 1);\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_mouseOverHandler\n         * @desc Handle mouseover event on mega menu.\n         * @param {event} Event object\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _mouseOverHandler = function (event) {\n            clearTimeout(this.mouseTimeoutID);\n            $(event.target)\n                .addClass(this.settings.hoverClass);\n            _togglePanel.call(this, event);\n            if ($(event.target).is(':tabbable')) {\n                $('html').on('keydown.accessible-megamenu', $.proxy(_keyDownHandler, event.target));\n            }\n        };\n\n        /**\n         * @name jQuery.fn.accessibleMegaMenu~_mouseOutHandler\n         * @desc Handle mouseout event on mega menu.\n         * @param {event} Event object\n         * @memberof jQuery.fn.accessibleMegaMenu\n         * @inner\n         * @private\n         */\n        _mouseOutHandler = function (event) {\n            var that = this;\n            $(event.target)\n                .removeClass(that.settings.hoverClass);\n\n            that.mouseTimeoutID = setTimeout(function () {\n                _togglePanel.call(that, event, true);\n            }, 250);\n            if ($(event.target).is(':tabbable')) {\n                $('html').off('keydown.accessible-megamenu');\n            }\n        };\n\n        _toggleExpandedEventHandlers = function (hide) {\n            var menu = this.menu;\n            if (hide) {\n                $('html').off('mouseup.outside-accessible-megamenu, touchend.outside-accessible-megamenu, mspointerup.outside-accessible-megamenu,  pointerup.outside-accessible-megamenu');\n\n                menu.find('[aria-expanded].' + this.settings.panelClass).off('DOMAttrModified.accessible-megamenu');\n            } else {\n                $('html').on('mouseup.outside-accessible-megamenu, touchend.outside-accessible-megamenu, mspointerup.outside-accessible-megamenu,  pointerup.outside-accessible-megamenu', $.proxy(_clickOutsideHandler, this));\n\n                /* Narrator in Windows 8 automatically toggles the aria-expanded property on double tap or click.\n                   To respond to the change to collapse the panel, we must add a listener for a DOMAttrModified event. */\n                menu.find('[aria-expanded=true].' + this.settings.panelClass).on('DOMAttrModified.accessible-megamenu', $.proxy(_DOMAttrModifiedHandler, this));\n            }\n        };\n\n        /* public attributes and methods ------------------------- */\n        return {\n            constructor: AccessibleMegaMenu,\n\n            /**\n             * @lends jQuery.fn.accessibleMegaMenu\n             * @desc Initializes an instance of the accessibleMegaMenu plugins\n             * @memberof jQuery.fn.accessibleMegaMenu\n             * @instance\n             */\n            init: function () {\n                var settings = this.settings,\n                    nav = $(this.element),\n                    menu = nav.children('ul').first(),\n                    topnavitems = menu.children();\n                this.start(settings, nav, menu, topnavitems);\n            },\n\n            start: function(settings, nav, menu, topnavitems) {\n                var that = this;\n                const CLASS_PRIMARY_TOOLS_LIST = 'pn-link--tools';\n                const CLASS_PRIMARY_UTILITY_LIST = 'pn-link--utility';\n                this.settings = settings;\n                this.menu = menu;\n                this.topnavitems = topnavitems;\n\n                nav.attr(\"role\", \"navigation\");\n                menu.addClass(settings.menuClass);\n                topnavitems.each(function (i, topnavitem) {\n                    var topnavitemlink, topnavitempanel;\n                    topnavitem = $(topnavitem);\n                    topnavitem.addClass(settings.topNavItemClass);\n                    topnavitemlink = topnavitem.find(\":tabbable:first\");\n                    topnavitempanel = topnavitem.children(\":not(:tabbable):last\");\n                    _addUniqueId.call(that, topnavitemlink);\n                    if (topnavitempanel.length) {\n                        _addUniqueId.call(that, topnavitempanel);\n                        if (!topnavitempanel.hasClass('is-open')) {\n                          //DTN-1565: Tools and Utility has no collapse/expand\n                          if (!(topnavitemlink.hasClass(CLASS_PRIMARY_TOOLS_LIST) || topnavitemlink.hasClass(CLASS_PRIMARY_UTILITY_LIST))) {\n                            topnavitemlink.attr({\n                              \"aria-expanded\": false\n                          });\n                          }\n                        }\n\n                        // only set aria-expanded and aria-hidden for panel that is not open.\n                        // 'is-open' attribute is set on the aem sightly template (primary-nav.html)\n                        // e.g. if we're on a page that is under Business, then dom for business panel is 'is-open'\n                        if (!topnavitempanel.hasClass('is-open')) {\n                          topnavitempanel.attr({\n                              \"role\": \"group\",\n                              \"aria-expanded\": false,\n                              \"aria-hidden\": true\n                          })\n                            .addClass(settings.panelClass);\n                        }\n                    }\n                });\n\n                this.panels = menu.find(\".\" + settings.panelClass);\n\n                menu.on(\"focusin.accessible-megamenu\", \":focusable, .\" + settings.panelClass, $.proxy(_focusInHandler, this))\n                    .on(\"focusout.accessible-megamenu\", \":focusable, .\" + settings.panelClass, $.proxy(_focusOutHandler, this))\n                    .on(\"keydown.accessible-megamenu\", $.proxy(_keyDownHandler, this))\n                    .on(\"mouseover.accessible-megamenu\", $.proxy(_mouseOverHandler, this))\n                    .on(\"mouseout.accessible-megamenu\", $.proxy(_mouseOutHandler, this))\n                    .on(\"mousedown.accessible-megamenu\", $.proxy(_mouseDownHandler, this));\n\n                if (isTouch) {\n                    menu.on(\"touchstart.accessible-megamenu\",  $.proxy(_clickHandler, this));\n                }\n\n                menu.find(\"hr\").attr(\"role\", \"separator\");\n\n                if ($(document.activeElement).closest(menu).length) {\n                  $(document.activeElement).trigger(\"focusin.accessible-megamenu\");\n                }\n            },\n\n            /**\n             * @desc Get default values\n             * @example $(selector).accessibleMegaMenu(\"getDefaults\");\n             * @return {object}\n             * @memberof jQuery.fn.accessibleMegaMenu\n             * @instance\n             */\n            getDefaults: function () {\n                return this._defaults;\n            },\n\n            /**\n             * @desc Get any option set to plugin using its name (as string)\n             * @example $(selector).accessibleMegaMenu(\"getOption\", some_option);\n             * @param {string} opt\n             * @return {string}\n             * @memberof jQuery.fn.accessibleMegaMenu\n             * @instance\n             */\n            getOption: function (opt) {\n                return this.settings[opt];\n            },\n\n            /**\n             * @desc Get all options\n             * @example $(selector).accessibleMegaMenu(\"getAllOptions\");\n             * @return {object}\n             * @memberof jQuery.fn.accessibleMegaMenu\n             * @instance\n             */\n            getAllOptions: function () {\n                return this.settings;\n            },\n\n            /**\n             * @desc Set option\n             * @example $(selector).accessibleMegaMenu(\"setOption\", \"option_name\",  \"option_value\",  reinitialize);\n             * @param {string} opt - Option name\n             * @param {string} val - Option value\n             * @param {boolean} [reinitialize] - boolean to re-initialize the menu.\n             * @memberof jQuery.fn.accessibleMegaMenu\n             * @instance\n             */\n            setOption: function (opt, value, reinitialize) {\n                this.settings[opt] = value;\n                if (reinitialize) {\n                    this.init();\n                }\n            }\n        };\n    }());\n\n\n    $.fn[pluginName] = function (options) {\n        return this.each(function () {\n            if (!$.data(this, \"plugin_\" + pluginName)) {\n                $.data(this, \"plugin_\" + pluginName, new $.fn[pluginName].AccessibleMegaMenu(this, options));\n            }\n        });\n    };\n\n    $.fn[pluginName].AccessibleMegaMenu = AccessibleMegaMenu;\n\n    /**\n     * @private\n     */\n    function visible(element) {\n        return $.expr.filters.visible(element) && !$(element).parents().addBack().filter(function () {\n            return $.css(this, \"visibility\") === \"hidden\";\n        }).length;\n    }\n\n    /**\n     * @private\n     */\n    function focusable(element, isTabIndexNotNaN) {\n        var map, mapName, img,\n            nodeName = element.nodeName.toLowerCase();\n        if (\"area\" === nodeName) {\n            map = element.parentNode;\n            mapName = map.name;\n            if (!element.href || !mapName || map.nodeName.toLowerCase() !== \"map\") {\n                return false;\n            }\n            img = $(\"img[usemap=#\" + mapName + \"]\")[0];\n            return !!img && visible(img);\n        }\n        return (/input|select|textarea|button|object/.test(nodeName) ? !element.disabled :\n                \"a\" === nodeName ?\n                        element.href || isTabIndexNotNaN :\n                        isTabIndexNotNaN) &&\n                            // the element and all of its ancestors must be visible\n                            visible(element);\n    }\n\n    $.extend($.expr[\":\"], {\n        data: $.expr.createPseudo ? $.expr.createPseudo(function (dataName) {\n            return function (elem) {\n                return !!$.data(elem, dataName);\n            };\n        }) : // support: jQuery <1.8\n                function (elem, i, match) {\n                    return !!$.data(elem, match[3]);\n                },\n\n        focusable: function (element) {\n            return focusable(element, !isNaN($.attr(element, \"tabindex\")));\n        },\n\n        tabbable: function (element) {\n            var tabIndex = $.attr(element, \"tabindex\"),\n                isTabIndexNaN = isNaN(tabIndex);\n            return (isTabIndexNaN || tabIndex >= 0) && focusable(element, !isTabIndexNaN);\n        }\n    });\n}(jQuery, window, document));\n"],"mappings":"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"}
//# sourceURL=webpack-internal:///115

$(document).ready(function() {
    var stickyOffset = 200;
    var $sticky = $('.fbtn__button');

    if ($('.fbtn__button').length) {
        $(window).on('scroll', function() {
            var scroll = $(window).scrollTop();

            if (scroll > stickyOffset) {
                $sticky.addClass('fbtn__button--show');
            }

            if (scroll < stickyOffset) {
                $sticky.removeClass('fbtn__button--show');
            }
        });
    }
}); //# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9hZW0tY21zLWNvZGUvLi91aS5hcHBzL3NyYy9tYWluL2NvbnRlbnQvamNyX3Jvb3QvYXBwcy9nbG9iYWwvY29tcG9uZW50cy9mZWVkYmFjay1idXR0b24vY2xpZW50bGliL3NyYy9qcy9mZWVkYmFjay1idXR0b24uanM/ODYyYyJdLCJuYW1lcyI6WyIkIiwiZG9jdW1lbnQiLCJyZWFkeSIsInN0aWNreU9mZnNldCIsIiRzdGlja3kiLCJsZW5ndGgiLCJ3aW5kb3ciLCJvbiIsInNjcm9sbCIsInNjcm9sbFRvcCIsImFkZENsYXNzIiwicmVtb3ZlQ2xhc3MiXSwibWFwcGluZ3MiOiJBQUFhOztBQUNiQSxDQUFDLENBQUNDLFFBQUQsQ0FBRCxDQUFZQyxLQUFaLENBQWtCLFlBQU07RUFDdEIsSUFBSUMsWUFBWSxHQUFHLEdBQW5CO0VBQ0EsSUFBSUMsT0FBTyxHQUFHSixDQUFDLENBQUMsZUFBRCxDQUFmOztFQUVBLElBQUlBLENBQUMsQ0FBQyxlQUFELENBQUQsQ0FBbUJLLE1BQXZCLEVBQStCO0lBQzdCTCxDQUFDLENBQUNNLE1BQUQsQ0FBRCxDQUFVQyxFQUFWLENBQWEsUUFBYixFQUF1QixZQUFXO01BQ2hDLElBQUlDLE1BQU0sR0FBR1IsQ0FBQyxDQUFDTSxNQUFELENBQUQsQ0FBVUcsU0FBVixFQUFiOztNQUNBLElBQUlELE1BQU0sR0FBR0wsWUFBYixFQUEyQjtRQUN6QkMsT0FBTyxDQUFDTSxRQUFSLENBQWlCLG9CQUFqQjtNQUNEOztNQUNELElBQUlGLE1BQU0sR0FBR0wsWUFBYixFQUEyQjtRQUN6QkMsT0FBTyxDQUFDTyxXQUFSLENBQW9CLG9CQUFwQjtNQUNEO0lBQ0YsQ0FSRDtFQVNEO0FBQ0YsQ0FmRCIsImZpbGUiOiIzNjQ1LmpzIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuJChkb2N1bWVudCkucmVhZHkoKCkgPT4ge1xuICBsZXQgc3RpY2t5T2Zmc2V0ID0gMjAwO1xuICBsZXQgJHN0aWNreSA9ICQoJy5mYnRuX19idXR0b24nKTtcblxuICBpZiAoJCgnLmZidG5fX2J1dHRvbicpLmxlbmd0aCkge1xuICAgICQod2luZG93KS5vbignc2Nyb2xsJywgZnVuY3Rpb24oKSB7XG4gICAgICBsZXQgc2Nyb2xsID0gJCh3aW5kb3cpLnNjcm9sbFRvcCgpO1xuICAgICAgaWYgKHNjcm9sbCA+IHN0aWNreU9mZnNldCkge1xuICAgICAgICAkc3RpY2t5LmFkZENsYXNzKCdmYnRuX19idXR0b24tLXNob3cnKTtcbiAgICAgIH1cbiAgICAgIGlmIChzY3JvbGwgPCBzdGlja3lPZmZzZXQpIHtcbiAgICAgICAgJHN0aWNreS5yZW1vdmVDbGFzcygnZmJ0bl9fYnV0dG9uLS1zaG93Jyk7XG4gICAgICB9XG4gICAgfSk7XG4gIH1cbn0pO1xuIl0sInNvdXJjZVJvb3QiOiIifQ==
//# sourceURL=webpack-internal:///3645

var __WEBPACK_AMD_DEFINE_RESULT__;
/*! picturefill - v3.0.2 - 2016-02-12
 * https://scottjehl.github.io/picturefill/
 * Copyright (c) 2016 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT
 */
/*! Gecko-Picture - v1.0
 * https://github.com/scottjehl/picturefill/tree/3.0/src/plugins/gecko-picture
 * Firefox's early picture implementation (prior to FF41) is static and does
 * not react to viewport changes. This tiny module fixes this.
 */
(function(window) {
    /*jshint eqnull:true */
    var ua = navigator.userAgent;

    if (window.HTMLPictureElement && ((/ecko/).test(ua) && ua.match(/rv\:(\d+)/) && RegExp.$1 < 45)) {
        addEventListener("resize", (function() {
            var timer;

            var dummySrc = document.createElement("source");

            var fixRespimg = function(img) {
                var source, sizes;
                var picture = img.parentNode;

                if (picture.nodeName.toUpperCase() === "PICTURE") {
                    source = dummySrc.cloneNode();

                    picture.insertBefore(source, picture.firstElementChild);
                    setTimeout(function() {
                        picture.removeChild(source);
                    });
                } else if (!img._pfLastSize || img.offsetWidth > img._pfLastSize) {
                    img._pfLastSize = img.offsetWidth;
                    sizes = img.sizes;
                    img.sizes += ",100vw";
                    setTimeout(function() {
                        img.sizes = sizes;
                    });
                }
            };

            var findPictureImgs = function() {
                var i;
                var imgs = document.querySelectorAll("picture > img, img[srcset][sizes]");
                for (i = 0; i < imgs.length; i++) {
                    fixRespimg(imgs[i]);
                }
            };
            var onResize = function() {
                clearTimeout(timer);
                timer = setTimeout(findPictureImgs, 99);
            };
            var mq = window.matchMedia && matchMedia("(orientation: landscape)");
            var init = function() {
                onResize();

                if (mq && mq.addListener) {
                    mq.addListener(onResize);
                }
            };

            dummySrc.srcset = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";

            if (/^[c|i]|d$/.test(document.readyState || "")) {
                init();
            } else {
                document.addEventListener("DOMContentLoaded", init);
            }

            return onResize;
        })());
    }
})(window);

/*! Picturefill - v3.0.2
 * http://scottjehl.github.io/picturefill
 * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt;
 *  License: MIT
 */

(function(window, document, undefined) {
    // Enable strict mode
    "use strict";

    // HTML shim|v it for old IE (IE9 will still need the HTML video tag workaround)
    document.createElement("picture");

    var warn, eminpx, alwaysCheckWDescriptor, evalId;
    // local object for method references and testing exposure
    var pf = {};
    var isSupportTestReady = false;
    var noop = function() {};
    var image = document.createElement("img");
    var getImgAttr = image.getAttribute;
    var setImgAttr = image.setAttribute;
    var removeImgAttr = image.removeAttribute;
    var docElem = document.documentElement;
    var types = {};
    var cfg = {
        //resource selection:
        algorithm: ""
    };
    var srcAttr = "data-pfsrc";
    var srcsetAttr = srcAttr + "set";
    // ua sniffing is done for undetectable img loading features,
    // to do some non crucial perf optimizations
    var ua = navigator.userAgent;
    var supportAbort = (/rident/).test(ua) || ((/ecko/).test(ua) && ua.match(/rv\:(\d+)/) && RegExp.$1 > 35);
    var curSrcProp = "currentSrc";
    var regWDesc = /\s+\+?\d+(e\d+)?w/;
    var regSize = /(\([^)]+\))?\s*(.+)/;
    var setOptions = window.picturefillCFG;
    /**
     * Shortcut property for https://w3c.github.io/webappsec/specs/mixedcontent/#restricts-mixed-content ( for easy overriding in tests )
     */
    // baseStyle also used by getEmValue (i.e.: width: 1em is important)
    var baseStyle = "position:absolute;left:0;visibility:hidden;display:block;padding:0;border:none;font-size:1em;width:1em;overflow:hidden;clip:rect(0px, 0px, 0px, 0px)";
    var fsCss = "font-size:100%!important;";
    var isVwDirty = true;

    var cssCache = {};
    var sizeLengthCache = {};
    var DPR = window.devicePixelRatio;
    var units = {
        px: 1,
        "in": 96
    };
    var anchor = document.createElement("a");
    /**
     * alreadyRun flag used for setOptions. is it true setOptions will reevaluate
     * @type {boolean}
     */
    var alreadyRun = false;

    // Reusable, non-"g" Regexes

    // (Don't use \s, to avoid matching non-breaking space.)
    var regexLeadingSpaces = /^[ \t\n\r\u000c]+/,
        regexLeadingCommasOrSpaces = /^[, \t\n\r\u000c]+/,
        regexLeadingNotSpaces = /^[^ \t\n\r\u000c]+/,
        regexTrailingCommas = /[,]+$/,
        regexNonNegativeInteger = /^\d+$/,

        // ( Positive or negative or unsigned integers or decimals, without or without exponents.
        // Must include at least one digit.
        // According to spec tests any decimal point must be followed by a digit.
        // No leading plus sign is allowed.)
        // https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number
        regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;

    var on = function(obj, evt, fn, capture) {
        if (obj.addEventListener) {
            obj.addEventListener(evt, fn, capture || false);
        } else if (obj.attachEvent) {
            obj.attachEvent("on" + evt, fn);
        }
    };

    /**
     * simple memoize function:
     */

    var memoize = function(fn) {
        var cache = {};
        return function(input) {
            if (!(input in cache)) {
                cache[input] = fn(input);
            }
            return cache[input];
        };
    };

    // UTILITY FUNCTIONS

    // Manual is faster than RegEx
    // http://jsperf.com/whitespace-character/5
    function isSpace(c) {
        return (c === "\u0020" || // space
            c === "\u0009" || // horizontal tab
            c === "\u000A" || // new line
            c === "\u000C" || // form feed
            c === "\u000D"); // carriage return
    }

    /**
     * gets a mediaquery and returns a boolean or gets a css length and returns a number
     * @param css mediaqueries or css length
     * @returns {boolean|number}
     *
     * based on: https://gist.github.com/jonathantneal/db4f77009b155f083738
     */
    var evalCSS = (function() {

        var regLength = /^([\d\.]+)(em|vw|px)$/;
        var replace = function() {
            var args = arguments,
                index = 0,
                string = args[0];
            while (++index in args) {
                string = string.replace(args[index], args[++index]);
            }
            return string;
        };

        var buildStr = memoize(function(css) {

            return "return " + replace((css || "").toLowerCase(),
                // interpret `and`
                /\band\b/g, "&&",

                // interpret `,`
                /,/g, "||",

                // interpret `min-` as >=
                /min-([a-z-\s]+):/g, "e.$1>=",

                // interpret `max-` as <=
                /max-([a-z-\s]+):/g, "e.$1<=",

                //calc value
                /calc([^)]+)/g, "($1)",

                // interpret css values
                /(\d+[\.]*[\d]*)([a-z]+)/g, "($1 * e.$2)",
                //make eval less evil
                /^(?!(e.[a-z]|[0-9\.&=|><\+\-\*\(\)\/])).*/ig, ""
            ) + ";";
        });

        return function(css, length) {
            var parsedLength;
            if (!(css in cssCache)) {
                cssCache[css] = false;
                if (length && (parsedLength = css.match(regLength))) {
                    cssCache[css] = parsedLength[1] * units[parsedLength[2]];
                } else {
                    /*jshint evil:true */
                    try {
                        cssCache[css] = new Function("e", buildStr(css))(units);
                    } catch (e) {}
                    /*jshint evil:false */
                }
            }
            return cssCache[css];
        };
    })();

    var setResolution = function(candidate, sizesattr) {
        if (candidate.w) { // h = means height: || descriptor.type === 'h' do not handle yet...
            candidate.cWidth = pf.calcListLength(sizesattr || "100vw");
            candidate.res = candidate.w / candidate.cWidth;
        } else {
            candidate.res = candidate.d;
        }
        return candidate;
    };

    /**
     *
     * @param opt
     */
    var picturefill = function(opt) {

        if (!isSupportTestReady) {
            return;
        }

        var elements, i, plen;

        var options = opt || {};

        if (options.elements && options.elements.nodeType === 1) {
            if (options.elements.nodeName.toUpperCase() === "IMG") {
                options.elements = [options.elements];
            } else {
                options.context = options.elements;
                options.elements = null;
            }
        }

        elements = options.elements || pf.qsa((options.context || document), (options.reevaluate || options.reselect) ? pf.sel : pf.selShort);

        if ((plen = elements.length)) {

            pf.setupRun(options);
            alreadyRun = true;

            // Loop through all elements
            for (i = 0; i < plen; i++) {
                pf.fillImg(elements[i], options);
            }

            pf.teardownRun(options);
        }
    };

    /**
     * outputs a warning for the developer
     * @param {message}
     * @type {Function}
     */
    warn = (window.console && console.warn) ?
        function(message) {
            console.warn(message);
        } :
        noop;

    if (!(curSrcProp in image)) {
        curSrcProp = "src";
    }

    // Add support for standard mime types.
    types["image/jpeg"] = true;
    types["image/gif"] = true;
    types["image/png"] = true;

    function detectTypeSupport(type, typeUri) {
        // based on Modernizr's lossless img-webp test
        // note: asynchronous
        var image = new window.Image();
        image.onerror = function() {
            types[type] = false;
            picturefill();
        };
        image.onload = function() {
            types[type] = image.width === 1;
            picturefill();
        };
        image.src = typeUri;
        return "pending";
    }

    // test svg support
    types["image/svg+xml"] = document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#Image", "1.1");

    /**
     * updates the internal vW property with the current viewport width in px
     */
    function updateMetrics() {

        isVwDirty = false;
        DPR = window.devicePixelRatio;
        cssCache = {};
        sizeLengthCache = {};

        pf.DPR = DPR || 1;

        units.width = Math.max(window.innerWidth || 0, docElem.clientWidth);
        units.height = Math.max(window.innerHeight || 0, docElem.clientHeight);

        units.vw = units.width / 100;
        units.vh = units.height / 100;

        evalId = [units.height, units.width, DPR].join("-");

        units.em = pf.getEmValue();
        units.rem = units.em;
    }

    function chooseLowRes(lowerValue, higherValue, dprValue, isCached) {
        var bonusFactor, tooMuch, bonus, meanDensity;

        //experimental
        if (cfg.algorithm === "saveData") {
            if (lowerValue > 2.7) {
                meanDensity = dprValue + 1;
            } else {
                tooMuch = higherValue - dprValue;
                bonusFactor = Math.pow(lowerValue - 0.6, 1.5);

                bonus = tooMuch * bonusFactor;

                if (isCached) {
                    bonus += 0.1 * bonusFactor;
                }

                meanDensity = lowerValue + bonus;
            }
        } else {
            meanDensity = (dprValue > 1) ?
                Math.sqrt(lowerValue * higherValue) :
                lowerValue;
        }

        return meanDensity > dprValue;
    }

    function applyBestCandidate(img) {
        var srcSetCandidates;
        var matchingSet = pf.getSet(img);
        var evaluated = false;
        if (matchingSet !== "pending") {
            evaluated = evalId;
            if (matchingSet) {
                srcSetCandidates = pf.setRes(matchingSet);
                pf.applySetCandidate(srcSetCandidates, img);
            }
        }
        img[pf.ns].evaled = evaluated;
    }

    function ascendingSort(a, b) {
        return a.res - b.res;
    }

    function setSrcToCur(img, src, set) {
        var candidate;
        if (!set && src) {
            set = img[pf.ns].sets;
            set = set && set[set.length - 1];
        }

        candidate = getCandidateForSrc(src, set);

        if (candidate) {
            src = pf.makeUrl(src);
            img[pf.ns].curSrc = src;
            img[pf.ns].curCan = candidate;

            if (!candidate.res) {
                setResolution(candidate, candidate.set.sizes);
            }
        }
        return candidate;
    }

    function getCandidateForSrc(src, set) {
        var i, candidate, candidates;
        if (src && set) {
            candidates = pf.parseSet(set);
            src = pf.makeUrl(src);
            for (i = 0; i < candidates.length; i++) {
                if (src === pf.makeUrl(candidates[i].url)) {
                    candidate = candidates[i];
                    break;
                }
            }
        }
        return candidate;
    }

    function getAllSourceElements(picture, candidates) {
        var i, len, source, srcset;

        // SPEC mismatch intended for size and perf:
        // actually only source elements preceding the img should be used
        // also note: don't use qsa here, because IE8 sometimes doesn't like source as the key part in a selector
        var sources = picture.getElementsByTagName("source");

        for (i = 0, len = sources.length; i < len; i++) {
            source = sources[i];
            source[pf.ns] = true;
            srcset = source.getAttribute("srcset");

            // if source does not have a srcset attribute, skip
            if (srcset) {
                candidates.push({
                    srcset: srcset,
                    media: source.getAttribute("media"),
                    type: source.getAttribute("type"),
                    sizes: source.getAttribute("sizes")
                });
            }
        }
    }

    /**
     * Srcset Parser
     * By Alex Bell |  MIT License
     *
     * @returns Array [{url: _, d: _, w: _, h:_, set:_(????)}, ...]
     *
     * Based super duper closely on the reference algorithm at:
     * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute
     */

    // 1. Let input be the value passed to this algorithm.
    // (TO-DO : Explain what "set" argument is here. Maybe choose a more
    // descriptive & more searchable name.  Since passing the "set" in really has
    // nothing to do with parsing proper, I would prefer this assignment eventually
    // go in an external fn.)
    function parseSrcset(input, set) {

        function collectCharacters(regEx) {
            var chars,
                match = regEx.exec(input.substring(pos));
            if (match) {
                chars = match[0];
                pos += chars.length;
                return chars;
            }
        }

        var inputLength = input.length,
            url,
            descriptors,
            currentDescriptor,
            state,
            c,

            // 2. Let position be a pointer into input, initially pointing at the start
            //    of the string.
            pos = 0,

            // 3. Let candidates be an initially empty source set.
            candidates = [];

        /**
         * Adds descriptor properties to a candidate, pushes to the candidates array
         * @return undefined
         */
        // (Declared outside of the while loop so that it's only created once.
        // (This fn is defined before it is used, in order to pass JSHINT.
        // Unfortunately this breaks the sequencing of the spec comments. :/ )
        function parseDescriptors() {

                // 9. Descriptor parser: Let error be no.
                var pError = false,

                    // 10. Let width be absent.
                    // 11. Let density be absent.
                    // 12. Let future-compat-h be absent. (We're implementing it now as h)
                    w, d, h, i,
                    candidate = {},
                    desc, lastChar, value, intVal, floatVal;

                // 13. For each descriptor in descriptors, run the appropriate set of steps
                // from the following list:
                for (i = 0; i < descriptors.length; i++) {
                    desc = descriptors[i];

                    lastChar = desc[desc.length - 1];
                    value = desc.substring(0, desc.length - 1);
                    intVal = parseInt(value, 10);
                    floatVal = parseFloat(value);

                    // If the descriptor consists of a valid non-negative integer followed by
                    // a U+0077 LATIN SMALL LETTER W character
                    if (regexNonNegativeInteger.test(value) && (lastChar === "w")) {

                        // If width and density are not both absent, then let error be yes.
                        if (w || d) {
                            pError = true;
                        }

                        // Apply the rules for parsing non-negative integers to the descriptor.
                        // If the result is zero, let error be yes.
                        // Otherwise, let width be the result.
                        if (intVal === 0) {
                            pError = true;
                        } else {
                            w = intVal;
                        }

                        // If the descriptor consists of a valid floating-point number followed by
                        // a U+0078 LATIN SMALL LETTER X character
                    } else if (regexFloatingPoint.test(value) && (lastChar === "x")) {

                        // If width, density and future-compat-h are not all absent, then let error
                        // be yes.
                        if (w || d || h) {
                            pError = true;
                        }

                        // Apply the rules for parsing floating-point number values to the descriptor.
                        // If the result is less than zero, let error be yes. Otherwise, let density
                        // be the result.
                        if (floatVal < 0) {
                            pError = true;
                        } else {
                            d = floatVal;
                        }

                        // If the descriptor consists of a valid non-negative integer followed by
                        // a U+0068 LATIN SMALL LETTER H character
                    } else if (regexNonNegativeInteger.test(value) && (lastChar === "h")) {

                        // If height and density are not both absent, then let error be yes.
                        if (h || d) {
                            pError = true;
                        }

                        // Apply the rules for parsing non-negative integers to the descriptor.
                        // If the result is zero, let error be yes. Otherwise, let future-compat-h
                        // be the result.
                        if (intVal === 0) {
                            pError = true;
                        } else {
                            h = intVal;
                        }

                        // Anything else, Let error be yes.
                    } else {
                        pError = true;
                    }
                } // (close step 13 for loop)

                // 15. If error is still no, then append a new image source to candidates whose
                // URL is url, associated with a width width if not absent and a pixel
                // density density if not absent. Otherwise, there is a parse error.
                if (!pError) {
                    candidate.url = url;

                    if (w) {
                        candidate.w = w;
                    }
                    if (d) {
                        candidate.d = d;
                    }
                    if (h) {
                        candidate.h = h;
                    }
                    if (!h && !d && !w) {
                        candidate.d = 1;
                    }
                    if (candidate.d === 1) {
                        set.has1x = true;
                    }
                    candidate.set = set;

                    candidates.push(candidate);
                }
            } // (close parseDescriptors fn)

        /**
         * Tokenizes descriptor properties prior to parsing
         * Returns undefined.
         * (Again, this fn is defined before it is used, in order to pass JSHINT.
         * Unfortunately this breaks the logical sequencing of the spec comments. :/ )
         */
        function tokenize() {

            // 8.1. Descriptor tokeniser: Skip whitespace
            collectCharacters(regexLeadingSpaces);

            // 8.2. Let current descriptor be the empty string.
            currentDescriptor = "";

            // 8.3. Let state be in descriptor.
            state = "in descriptor";

            while (true) {

                // 8.4. Let c be the character at position.
                c = input.charAt(pos);

                //  Do the following depending on the value of state.
                //  For the purpose of this step, "EOF" is a special character representing
                //  that position is past the end of input.

                // In descriptor
                if (state === "in descriptor") {
                    // Do the following, depending on the value of c:

                    // Space character
                    // If current descriptor is not empty, append current descriptor to
                    // descriptors and let current descriptor be the empty string.
                    // Set state to after descriptor.
                    if (isSpace(c)) {
                        if (currentDescriptor) {
                            descriptors.push(currentDescriptor);
                            currentDescriptor = "";
                            state = "after descriptor";
                        }

                        // U+002C COMMA (,)
                        // Advance position to the next character in input. If current descriptor
                        // is not empty, append current descriptor to descriptors. Jump to the step
                        // labeled descriptor parser.
                    } else if (c === ",") {
                        pos += 1;
                        if (currentDescriptor) {
                            descriptors.push(currentDescriptor);
                        }
                        parseDescriptors();
                        return;

                        // U+0028 LEFT PARENTHESIS (()
                        // Append c to current descriptor. Set state to in parens.
                    } else if (c === "\u0028") {
                        currentDescriptor = currentDescriptor + c;
                        state = "in parens";

                        // EOF
                        // If current descriptor is not empty, append current descriptor to
                        // descriptors. Jump to the step labeled descriptor parser.
                    } else if (c === "") {
                        if (currentDescriptor) {
                            descriptors.push(currentDescriptor);
                        }
                        parseDescriptors();
                        return;

                        // Anything else
                        // Append c to current descriptor.
                    } else {
                        currentDescriptor = currentDescriptor + c;
                    }
                    // (end "in descriptor"

                    // In parens
                } else if (state === "in parens") {

                    // U+0029 RIGHT PARENTHESIS ())
                    // Append c to current descriptor. Set state to in descriptor.
                    if (c === ")") {
                        currentDescriptor = currentDescriptor + c;
                        state = "in descriptor";

                        // EOF
                        // Append current descriptor to descriptors. Jump to the step labeled
                        // descriptor parser.
                    } else if (c === "") {
                        descriptors.push(currentDescriptor);
                        parseDescriptors();
                        return;

                        // Anything else
                        // Append c to current descriptor.
                    } else {
                        currentDescriptor = currentDescriptor + c;
                    }

                    // After descriptor
                } else if (state === "after descriptor") {

                    // Do the following, depending on the value of c:
                    // Space character: Stay in this state.
                    if (isSpace(c)) {

                        // EOF: Jump to the step labeled descriptor parser.
                    } else if (c === "") {
                        parseDescriptors();
                        return;

                        // Anything else
                        // Set state to in descriptor. Set position to the previous character in input.
                    } else {
                        state = "in descriptor";
                        pos -= 1;

                    }
                }

                // Advance position to the next character in input.
                pos += 1;

                // Repeat this step.
            } // (close while true loop)
        }

        // 4. Splitting loop: Collect a sequence of characters that are space
        //    characters or U+002C COMMA characters. If any U+002C COMMA characters
        //    were collected, that is a parse error.
        while (true) {
            collectCharacters(regexLeadingCommasOrSpaces);

            // 5. If position is past the end of input, return candidates and abort these steps.
            if (pos >= inputLength) {
                return candidates; // (we're done, this is the sole return path)
            }

            // 6. Collect a sequence of characters that are not space characters,
            //    and let that be url.
            url = collectCharacters(regexLeadingNotSpaces);

            // 7. Let descriptors be a new empty list.
            descriptors = [];

            // 8. If url ends with a U+002C COMMA character (,), follow these substeps:
            //		(1). Remove all trailing U+002C COMMA characters from url. If this removed
            //         more than one character, that is a parse error.
            if (url.slice(-1) === ",") {
                url = url.replace(regexTrailingCommas, "");
                // (Jump ahead to step 9 to skip tokenization and just push the candidate).
                parseDescriptors();

                //	Otherwise, follow these substeps:
            } else {
                tokenize();
            } // (close else of step 8)

            // 16. Return to the step labeled splitting loop.
        } // (Close of big while loop.)
    }

    /*
     * Sizes Parser
     *
     * By Alex Bell |  MIT License
     *
     * Non-strict but accurate and lightweight JS Parser for the string value <img sizes="here">
     *
     * Reference algorithm at:
     * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-sizes-attribute
     *
     * Most comments are copied in directly from the spec
     * (except for comments in parens).
     *
     * Grammar is:
     * <source-size-list> = <source-size># [ , <source-size-value> ]? | <source-size-value>
     * <source-size> = <media-condition> <source-size-value>
     * <source-size-value> = <length>
     * http://www.w3.org/html/wg/drafts/html/master/embedded-content.html#attr-img-sizes
     *
     * E.g. "(max-width: 30em) 100vw, (max-width: 50em) 70vw, 100vw"
     * or "(min-width: 30em), calc(30vw - 15px)" or just "30vw"
     *
     * Returns the first valid <css-length> with a media condition that evaluates to true,
     * or "100vw" if all valid media conditions evaluate to false.
     *
     */

    function parseSizes(strValue) {

        // (Percentage CSS lengths are not allowed in this case, to avoid confusion:
        // https://html.spec.whatwg.org/multipage/embedded-content.html#valid-source-size-list
        // CSS allows a single optional plus or minus sign:
        // http://www.w3.org/TR/CSS2/syndata.html#numbers
        // CSS is ASCII case-insensitive:
        // http://www.w3.org/TR/CSS2/syndata.html#characters )
        // Spec allows exponential notation for <number> type:
        // http://dev.w3.org/csswg/css-values/#numbers
        var regexCssLengthWithUnits = /^(?:[+-]?[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?(?:ch|cm|em|ex|in|mm|pc|pt|px|rem|vh|vmin|vmax|vw)$/i;

        // (This is a quick and lenient test. Because of optional unlimited-depth internal
        // grouping parens and strict spacing rules, this could get very complicated.)
        var regexCssCalc = /^calc\((?:[0-9a-z \.\+\-\*\/\(\)]+)\)$/i;

        var i;
        var unparsedSizesList;
        var unparsedSizesListLength;
        var unparsedSize;
        var lastComponentValue;
        var size;

        // UTILITY FUNCTIONS

        //  (Toy CSS parser. The goals here are:
        //  1) expansive test coverage without the weight of a full CSS parser.
        //  2) Avoiding regex wherever convenient.
        //  Quick tests: http://jsfiddle.net/gtntL4gr/3/
        //  Returns an array of arrays.)
        function parseComponentValues(str) {
            var chrctr;
            var component = "";
            var componentArray = [];
            var listArray = [];
            var parenDepth = 0;
            var pos = 0;
            var inComment = false;

            function pushComponent() {
                if (component) {
                    componentArray.push(component);
                    component = "";
                }
            }

            function pushComponentArray() {
                if (componentArray[0]) {
                    listArray.push(componentArray);
                    componentArray = [];
                }
            }

            // (Loop forwards from the beginning of the string.)
            while (true) {
                chrctr = str.charAt(pos);

                if (chrctr === "") { // ( End of string reached.)
                    pushComponent();
                    pushComponentArray();
                    return listArray;
                } else if (inComment) {
                    if ((chrctr === "*") && (str[pos + 1] === "/")) { // (At end of a comment.)
                        inComment = false;
                        pos += 2;
                        pushComponent();
                        continue;
                    } else {
                        pos += 1; // (Skip all characters inside comments.)
                        continue;
                    }
                } else if (isSpace(chrctr)) {
                    // (If previous character in loop was also a space, or if
                    // at the beginning of the string, do not add space char to
                    // component.)
                    if ((str.charAt(pos - 1) && isSpace(str.charAt(pos - 1))) || !component) {
                        pos += 1;
                        continue;
                    } else if (parenDepth === 0) {
                        pushComponent();
                        pos += 1;
                        continue;
                    } else {
                        // (Replace any space character with a plain space for legibility.)
                        chrctr = " ";
                    }
                } else if (chrctr === "(") {
                    parenDepth += 1;
                } else if (chrctr === ")") {
                    parenDepth -= 1;
                } else if (chrctr === ",") {
                    pushComponent();
                    pushComponentArray();
                    pos += 1;
                    continue;
                } else if ((chrctr === "/") && (str.charAt(pos + 1) === "*")) {
                    inComment = true;
                    pos += 2;
                    continue;
                }

                component = component + chrctr;
                pos += 1;
            }
        }

        function isValidNonNegativeSourceSizeValue(s) {
            if (regexCssLengthWithUnits.test(s) && (parseFloat(s) >= 0)) {
                return true;
            }
            if (regexCssCalc.test(s)) {
                return true;
            }
            // ( http://www.w3.org/TR/CSS2/syndata.html#numbers says:
            // "-0 is equivalent to 0 and is not a negative number." which means that
            // unitless zero and unitless negative zero must be accepted as special cases.)
            if ((s === "0") || (s === "-0") || (s === "+0")) {
                return true;
            }
            return false;
        }

        // When asked to parse a sizes attribute from an element, parse a
        // comma-separated list of component values from the value of the element's
        // sizes attribute (or the empty string, if the attribute is absent), and let
        // unparsed sizes list be the result.
        // http://dev.w3.org/csswg/css-syntax/#parse-comma-separated-list-of-component-values

        unparsedSizesList = parseComponentValues(strValue);
        unparsedSizesListLength = unparsedSizesList.length;

        // For each unparsed size in unparsed sizes list:
        for (i = 0; i < unparsedSizesListLength; i++) {
            unparsedSize = unparsedSizesList[i];

            // 1. Remove all consecutive <whitespace-token>s from the end of unparsed size.
            // ( parseComponentValues() already omits spaces outside of parens. )

            // If unparsed size is now empty, that is a parse error; continue to the next
            // iteration of this algorithm.
            // ( parseComponentValues() won't push an empty array. )

            // 2. If the last component value in unparsed size is a valid non-negative
            // <source-size-value>, let size be its value and remove the component value
            // from unparsed size. Any CSS function other than the calc() function is
            // invalid. Otherwise, there is a parse error; continue to the next iteration
            // of this algorithm.
            // http://dev.w3.org/csswg/css-syntax/#parse-component-value
            lastComponentValue = unparsedSize[unparsedSize.length - 1];

            if (isValidNonNegativeSourceSizeValue(lastComponentValue)) {
                size = lastComponentValue;
                unparsedSize.pop();
            } else {
                continue;
            }

            // 3. Remove all consecutive <whitespace-token>s from the end of unparsed
            // size. If unparsed size is now empty, return size and exit this algorithm.
            // If this was not the last item in unparsed sizes list, that is a parse error.
            if (unparsedSize.length === 0) {
                return size;
            }

            // 4. Parse the remaining component values in unparsed size as a
            // <media-condition>. If it does not parse correctly, or it does parse
            // correctly but the <media-condition> evaluates to false, continue to the
            // next iteration of this algorithm.
            // (Parsing all possible compound media conditions in JS is heavy, complicated,
            // and the payoff is unclear. Is there ever an situation where the
            // media condition parses incorrectly but still somehow evaluates to true?
            // Can we just rely on the browser/polyfill to do it?)
            unparsedSize = unparsedSize.join(" ");
            if (!(pf.matchesMedia(unparsedSize))) {
                continue;
            }

            // 5. Return size and exit this algorithm.
            return size;
        }

        // If the above algorithm exhausts unparsed sizes list without returning a
        // size value, return 100vw.
        return "100vw";
    }

    // namespace
    pf.ns = ("pf" + new Date().getTime()).substr(0, 9);

    // srcset support test
    pf.supSrcset = "srcset" in image;
    pf.supSizes = "sizes" in image;
    pf.supPicture = !!window.HTMLPictureElement;

    // UC browser does claim to support srcset and picture, but not sizes,
    // this extended test reveals the browser does support nothing
    if (pf.supSrcset && pf.supPicture && !pf.supSizes) {
        (function(image2) {
            image.srcset = "data:,a";
            image2.src = "data:,a";
            pf.supSrcset = image.complete === image2.complete;
            pf.supPicture = pf.supSrcset && pf.supPicture;
        })(document.createElement("img"));
    }

    // Safari9 has basic support for sizes, but does't expose the `sizes` idl attribute
    if (pf.supSrcset && !pf.supSizes) {

        (function() {
            var width2 = "data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw==";
            var width1 = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
            var img = document.createElement("img");
            var test = function() {
                var width = img.width;

                if (width === 2) {
                    pf.supSizes = true;
                }

                alwaysCheckWDescriptor = pf.supSrcset && !pf.supSizes;

                isSupportTestReady = true;
                // force async
                setTimeout(picturefill);
            };

            img.onload = test;
            img.onerror = test;
            img.setAttribute("sizes", "9px");

            img.srcset = width1 + " 1w," + width2 + " 9w";
            img.src = width1;
        })();

    } else {
        isSupportTestReady = true;
    }

    // using pf.qsa instead of dom traversing does scale much better,
    // especially on sites mixing responsive and non-responsive images
    pf.selShort = "picture>img,img[srcset]";
    pf.sel = pf.selShort;
    pf.cfg = cfg;

    /**
     * Shortcut property for `devicePixelRatio` ( for easy overriding in tests )
     */
    pf.DPR = (DPR || 1);
    pf.u = units;

    // container of supported mime types that one might need to qualify before using
    pf.types = types;

    pf.setSize = noop;

    /**
     * Gets a string and returns the absolute URL
     * @param src
     * @returns {String} absolute URL
     */

    pf.makeUrl = memoize(function(src) {
        anchor.href = src;
        return anchor.href;
    });

    /**
     * Gets a DOM element or document and a selctor and returns the found matches
     * Can be extended with jQuery/Sizzle for IE7 support
     * @param context
     * @param sel
     * @returns {NodeList|Array}
     */
    pf.qsa = function(context, sel) {
        return ("querySelector" in context) ? context.querySelectorAll(sel) : [];
    };

    /**
     * Shortcut method for matchMedia ( for easy overriding in tests )
     * wether native or pf.mMQ is used will be decided lazy on first call
     * @returns {boolean}
     */
    pf.matchesMedia = function() {
        if (window.matchMedia && (matchMedia("(min-width: 0.1em)") || {}).matches) {
            pf.matchesMedia = function(media) {
                return !media || (matchMedia(media).matches);
            };
        } else {
            pf.matchesMedia = pf.mMQ;
        }

        return pf.matchesMedia.apply(this, arguments);
    };

    /**
     * A simplified matchMedia implementation for IE8 and IE9
     * handles only min-width/max-width with px or em values
     * @param media
     * @returns {boolean}
     */
    pf.mMQ = function(media) {
        return media ? evalCSS(media) : true;
    };

    /**
     * Returns the calculated length in css pixel from the given sourceSizeValue
     * http://dev.w3.org/csswg/css-values-3/#length-value
     * intended Spec mismatches:
     * * Does not check for invalid use of CSS functions
     * * Does handle a computed length of 0 the same as a negative and therefore invalid value
     * @param sourceSizeValue
     * @returns {Number}
     */
    pf.calcLength = function(sourceSizeValue) {

        var value = evalCSS(sourceSizeValue, true) || false;
        if (value < 0) {
            value = false;
        }

        return value;
    };

    /**
     * Takes a type string and checks if its supported
     */

    pf.supportsType = function(type) {
        return (type) ? types[type] : true;
    };

    /**
     * Parses a sourceSize into mediaCondition (media) and sourceSizeValue (length)
     * @param sourceSizeStr
     * @returns {*}
     */
    pf.parseSize = memoize(function(sourceSizeStr) {
        var match = (sourceSizeStr || "").match(regSize);
        return {
            media: match && match[1],
            length: match && match[2]
        };
    });

    pf.parseSet = function(set) {
        if (!set.cands) {
            set.cands = parseSrcset(set.srcset, set);
        }
        return set.cands;
    };

    /**
     * returns 1em in css px for html/body default size
     * function taken from respondjs
     * @returns {*|number}
     */
    pf.getEmValue = function() {
        var body;
        if (!eminpx && (body = document.body)) {
            var div = document.createElement("div"),
                originalHTMLCSS = docElem.style.cssText,
                originalBodyCSS = body.style.cssText;

            div.style.cssText = baseStyle;

            // 1em in a media query is the value of the default font size of the browser
            // reset docElem and body to ensure the correct value is returned
            docElem.style.cssText = fsCss;
            body.style.cssText = fsCss;

            body.appendChild(div);
            eminpx = div.offsetWidth;
            body.removeChild(div);

            //also update eminpx before returning
            eminpx = parseFloat(eminpx, 10);

            // restore the original values
            docElem.style.cssText = originalHTMLCSS;
            body.style.cssText = originalBodyCSS;

        }
        return eminpx || 16;
    };

    /**
     * Takes a string of sizes and returns the width in pixels as a number
     */
    pf.calcListLength = function(sourceSizeListStr) {
        // Split up source size list, ie ( max-width: 30em ) 100%, ( max-width: 50em ) 50%, 33%
        //
        //                           or (min-width:30em) calc(30% - 15px)
        if (!(sourceSizeListStr in sizeLengthCache) || cfg.uT) {
            var winningLength = pf.calcLength(parseSizes(sourceSizeListStr));

            sizeLengthCache[sourceSizeListStr] = !winningLength ? units.width : winningLength;
        }

        return sizeLengthCache[sourceSizeListStr];
    };

    /**
     * Takes a candidate object with a srcset property in the form of url/
     * ex. "images/pic-medium.png 1x, images/pic-medium-2x.png 2x" or
     *     "images/pic-medium.png 400w, images/pic-medium-2x.png 800w" or
     *     "images/pic-small.png"
     * Get an array of image candidates in the form of
     *      {url: "/foo/bar.png", resolution: 1}
     * where resolution is http://dev.w3.org/csswg/css-values-3/#resolution-value
     * If sizes is specified, res is calculated
     */
    pf.setRes = function(set) {
        var candidates;
        if (set) {

            candidates = pf.parseSet(set);

            for (var i = 0, len = candidates.length; i < len; i++) {
                setResolution(candidates[i], set.sizes);
            }
        }
        return candidates;
    };

    pf.setRes.res = setResolution;

    pf.applySetCandidate = function(candidates, img) {
        if (!candidates.length) {
            return;
        }
        var candidate,
            i,
            j,
            length,
            bestCandidate,
            curSrc,
            curCan,
            candidateSrc,
            abortCurSrc;

        var imageData = img[pf.ns];
        var dpr = pf.DPR;

        curSrc = imageData.curSrc || img[curSrcProp];

        curCan = imageData.curCan || setSrcToCur(img, curSrc, candidates[0].set);

        // if we have a current source, we might either become lazy or give this source some advantage
        if (curCan && curCan.set === candidates[0].set) {

            // if browser can abort image request and the image has a higher pixel density than needed
            // and this image isn't downloaded yet, we skip next part and try to save bandwidth
            abortCurSrc = (supportAbort && !img.complete && curCan.res - 0.1 > dpr);

            if (!abortCurSrc) {
                curCan.cached = true;

                // if current candidate is "best", "better" or "okay",
                // set it to bestCandidate
                if (curCan.res >= dpr) {
                    bestCandidate = curCan;
                }
            }
        }

        if (!bestCandidate) {

            candidates.sort(ascendingSort);

            length = candidates.length;
            bestCandidate = candidates[length - 1];

            for (i = 0; i < length; i++) {
                candidate = candidates[i];
                if (candidate.res >= dpr) {
                    j = i - 1;

                    // we have found the perfect candidate,
                    // but let's improve this a little bit with some assumptions ;-)
                    if (candidates[j] &&
                        (abortCurSrc || curSrc !== pf.makeUrl(candidate.url)) &&
                        chooseLowRes(candidates[j].res, candidate.res, dpr, candidates[j].cached)) {

                        bestCandidate = candidates[j];

                    } else {
                        bestCandidate = candidate;
                    }
                    break;
                }
            }
        }

        if (bestCandidate) {

            candidateSrc = pf.makeUrl(bestCandidate.url);

            imageData.curSrc = candidateSrc;
            imageData.curCan = bestCandidate;

            if (candidateSrc !== curSrc) {
                pf.setSrc(img, bestCandidate);
            }
            pf.setSize(img);
        }
    };

    pf.setSrc = function(img, bestCandidate) {
        var origWidth;
        img.src = bestCandidate.url;

        // although this is a specific Safari issue, we don't want to take too much different code paths
        if (bestCandidate.set.type === "image/svg+xml") {
            origWidth = img.style.width;
            img.style.width = (img.offsetWidth + 1) + "px";

            // next line only should trigger a repaint
            // if... is only done to trick dead code removal
            if (img.offsetWidth + 1) {
                img.style.width = origWidth;
            }
        }
    };

    pf.getSet = function(img) {
        var i, set, supportsType;
        var match = false;
        var sets = img[pf.ns].sets;

        for (i = 0; i < sets.length && !match; i++) {
            set = sets[i];

            if (!set.srcset || !pf.matchesMedia(set.media) || !(supportsType = pf.supportsType(set.type))) {
                continue;
            }

            if (supportsType === "pending") {
                set = supportsType;
            }

            match = set;
            break;
        }

        return match;
    };

    pf.parseSets = function(element, parent, options) {
        var srcsetAttribute, imageSet, isWDescripor, srcsetParsed;

        var hasPicture = parent && parent.nodeName.toUpperCase() === "PICTURE";
        var imageData = element[pf.ns];

        if (imageData.src === undefined || options.src) {
            imageData.src = getImgAttr.call(element, "src");
            if (imageData.src) {
                setImgAttr.call(element, srcAttr, imageData.src);
            } else {
                removeImgAttr.call(element, srcAttr);
            }
        }

        if (imageData.srcset === undefined || options.srcset || !pf.supSrcset || element.srcset) {
            srcsetAttribute = getImgAttr.call(element, "srcset");
            imageData.srcset = srcsetAttribute;
            srcsetParsed = true;
        }

        imageData.sets = [];

        if (hasPicture) {
            imageData.pic = true;
            getAllSourceElements(parent, imageData.sets);
        }

        if (imageData.srcset) {
            imageSet = {
                srcset: imageData.srcset,
                sizes: getImgAttr.call(element, "sizes")
            };

            imageData.sets.push(imageSet);

            isWDescripor = (alwaysCheckWDescriptor || imageData.src) && regWDesc.test(imageData.srcset || "");

            // add normal src as candidate, if source has no w descriptor
            if (!isWDescripor && imageData.src && !getCandidateForSrc(imageData.src, imageSet) && !imageSet.has1x) {
                imageSet.srcset += ", " + imageData.src;
                imageSet.cands.push({
                    url: imageData.src,
                    d: 1,
                    set: imageSet
                });
            }

        } else if (imageData.src) {
            imageData.sets.push({
                srcset: imageData.src,
                sizes: null
            });
        }

        imageData.curCan = null;
        imageData.curSrc = undefined;

        // if img has picture or the srcset was removed or has a srcset and does not support srcset at all
        // or has a w descriptor (and does not support sizes) set support to false to evaluate
        imageData.supported = !(hasPicture || (imageSet && !pf.supSrcset) || (isWDescripor && !pf.supSizes));

        if (srcsetParsed && pf.supSrcset && !imageData.supported) {
            if (srcsetAttribute) {
                setImgAttr.call(element, srcsetAttr, srcsetAttribute);
                element.srcset = "";
            } else {
                removeImgAttr.call(element, srcsetAttr);
            }
        }

        if (imageData.supported && !imageData.srcset && ((!imageData.src && element.src) || element.src !== pf.makeUrl(imageData.src))) {
            if (imageData.src === null) {
                element.removeAttribute("src");
            } else {
                element.src = imageData.src;
            }
        }

        imageData.parsed = true;
    };

    pf.fillImg = function(element, options) {
        var imageData;
        var extreme = options.reselect || options.reevaluate;

        // expando for caching data on the img
        if (!element[pf.ns]) {
            element[pf.ns] = {};
        }

        imageData = element[pf.ns];

        // if the element has already been evaluated, skip it
        // unless `options.reevaluate` is set to true ( this, for example,
        // is set to true when running `picturefill` on `resize` ).
        if (!extreme && imageData.evaled === evalId) {
            return;
        }

        if (!imageData.parsed || options.reevaluate) {
            pf.parseSets(element, element.parentNode, options);
        }

        if (!imageData.supported) {
            applyBestCandidate(element);
        } else {
            imageData.evaled = evalId;
        }
    };

    pf.setupRun = function() {
        if (!alreadyRun || isVwDirty || (DPR !== window.devicePixelRatio)) {
            updateMetrics();
        }
    };

    // If picture is supported, well, that's awesome.
    if (pf.supPicture) {
        picturefill = noop;
        pf.fillImg = noop;
    } else {

        // Set up picture polyfill by polling the document
        (function() {
            var isDomReady;
            var regReady = window.attachEvent ? /d$|^c/ : /d$|^c|^i/;

            var run = function() {
                var readyState = document.readyState || "";

                timerId = setTimeout(run, readyState === "loading" ? 200 : 999);
                if (document.body) {
                    pf.fillImgs();
                    isDomReady = isDomReady || regReady.test(readyState);
                    if (isDomReady) {
                        clearTimeout(timerId);
                    }

                }
            };

            var timerId = setTimeout(run, document.body ? 9 : 99);

            // Also attach picturefill on resize and readystatechange
            // http://modernjavascript.blogspot.com/2013/08/building-better-debounce.html
            var debounce = function(func, wait) {
                var timeout, timestamp;
                var later = function() {
                    var last = (new Date()) - timestamp;

                    if (last < wait) {
                        timeout = setTimeout(later, wait - last);
                    } else {
                        timeout = null;
                        func();
                    }
                };

                return function() {
                    timestamp = new Date();

                    if (!timeout) {
                        timeout = setTimeout(later, wait);
                    }
                };
            };
            var lastClientWidth = docElem.clientHeight;
            var onResize = function() {
                isVwDirty = Math.max(window.innerWidth || 0, docElem.clientWidth) !== units.width || docElem.clientHeight !== lastClientWidth;
                lastClientWidth = docElem.clientHeight;
                if (isVwDirty) {
                    pf.fillImgs();
                }
            };

            on(window, "resize", debounce(onResize, 99));
            on(document, "readystatechange", run);
        })();
    }

    pf.picturefill = picturefill;
    //use this internally for easy monkey patching/performance testing
    pf.fillImgs = picturefill;
    pf.teardownRun = noop;

    /* expose methods for testing */
    picturefill._ = pf;

    window.picturefillCFG = {
        pf: pf,
        push: function(args) {
            var name = args.shift();
            if (typeof pf[name] === "function") {
                pf[name].apply(pf, args);
            } else {
                cfg[name] = args[0];
                if (alreadyRun) {
                    pf.fillImgs({
                        reselect: true
                    });
                }
            }
        }
    };

    while (setOptions && setOptions.length) {
        window.picturefillCFG.push(setOptions.shift());
    }

    /* expose picturefill */
    window.picturefill = picturefill;

    /* expose picturefill */
    if (true && typeof module.exports === "object") {
        // CommonJS, just export
        module.exports = picturefill;
    } else if (true) {
        // AMD support
        !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
                return picturefill;
            }).call(exports, __webpack_require__, exports, module),
            __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
    }

    // IE8 evals this sync, so it must be the last thing we do
    if (!pf.supPicture) {
        types["image/webp"] = detectTypeSupport("image/webp", "data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==");
    }

})(window, document);
//# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://aem-cms-code/./node_modules/picturefill/dist/picturefill.js?eec8"],"names":[],"mappings":"AAAA;AACA;AACA,uFAAuF;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA,eAAe,iBAAiB;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA,GAAG;AACH;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,OAAO,kBAAkB,cAAc,UAAU,YAAY,cAAc,UAAU,gBAAgB;AACzI,uCAAuC;AACvC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;AACA,sBAAsB;AACtB;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,4BAA4B;;AAE5B;;AAEA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA,eAAe,UAAU;AACzB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,YAAY;AACZ,WAAW;AACX;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,eAAe,uBAAuB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,oCAAoC,SAAS;AAC7C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,qBAAqB,qCAAqC;AAC1D;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA;AACA;AACA,eAAe,wBAAwB;AACvC;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,kBAAkB;;AAElB;AACA;AACA;AACA,wBAAwB,eAAe,OAAO;;AAE9C;AACA;AACA,KAAK;;AAEL;AACA;AACA,uBAAuB;;AAEvB;AACA;AACA;AACA,wBAAwB,eAAe,OAAO;;AAE9C;AACA;AACA,KAAK;;AAEL;AACA,kBAAkB;;AAElB;AACA;AACA;AACA,wBAAwB,eAAe,OAAO;;AAE9C;AACA,KAAK,OAAO;AACZ,IAAI;;AAEJ;AACA;AACA;AACA;AACA;;AAEA,YAAY;AACZ,YAAY;AACZ,YAAY;AACZ,yBAAyB;AACzB,4BAA4B;AAC5B;;AAEA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,IAAI;AACJ;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,sBAAsB;AACtB;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,IAAI;AACJ;AACA,IAAI;;AAEJ;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,wBAAwB;AACxB;AACA;AACA;AACA,KAAK;AACL,sDAAsD;AACtD;AACA;AACA;AACA;AACA,MAAM;AACN,eAAe;AACf;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,iEAAiE;AACjE,8BAA8B;AAC9B;AACA;AACA;AACA,qDAAqD;AACrD;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,aAAa,6BAA6B;AAC1C;;AAEA;AACA;;AAEA,2DAA2D;AAC3D;AACA;;AAEA;AACA;AACA;AACA,iDAAiD;AACjD;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;;AAEA;AACA,gCAAgC;AAChC,gCAAgC;AAChC;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;AAEH,EAAE;AACF;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,cAAc,OAAO;AACrB;;AAEA;AACA;AACA;AACA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,4CAA4C,SAAS;AACrD;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,eAAe,YAAY;AAC3B;AACA;AACA;;AAEA;AACA,mEAAmE;AACnE;AACA;AACA;;AAEA;;AAEA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,cAAc,2BAA2B;AACzC;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA,GAAG;AACH;AACA;AACA;AACA,IAAI;AACJ;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,EAAE;;AAEF;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,MAAM,KAA0B;AAChC;AACA;AACA,EAAE,WAAW,IAA0C;AACvD;AACA,EAAE,mCAAuB,YAAY,oBAAoB,EAAE;AAAA,kGAAE;AAC7D;;AAEA;AACA;AACA,2EAA2E;AAC3E;;AAEA,CAAC","file":"7229.js","sourcesContent":["/*! picturefill - v3.0.2 - 2016-02-12\n * https://scottjehl.github.io/picturefill/\n * Copyright (c) 2016 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT\n */\n/*! Gecko-Picture - v1.0\n * https://github.com/scottjehl/picturefill/tree/3.0/src/plugins/gecko-picture\n * Firefox's early picture implementation (prior to FF41) is static and does\n * not react to viewport changes. This tiny module fixes this.\n */\n(function(window) {\n\t/*jshint eqnull:true */\n\tvar ua = navigator.userAgent;\n\n\tif ( window.HTMLPictureElement && ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 < 45) ) {\n\t\taddEventListener(\"resize\", (function() {\n\t\t\tvar timer;\n\n\t\t\tvar dummySrc = document.createElement(\"source\");\n\n\t\t\tvar fixRespimg = function(img) {\n\t\t\t\tvar source, sizes;\n\t\t\t\tvar picture = img.parentNode;\n\n\t\t\t\tif (picture.nodeName.toUpperCase() === \"PICTURE\") {\n\t\t\t\t\tsource = dummySrc.cloneNode();\n\n\t\t\t\t\tpicture.insertBefore(source, picture.firstElementChild);\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tpicture.removeChild(source);\n\t\t\t\t\t});\n\t\t\t\t} else if (!img._pfLastSize || img.offsetWidth > img._pfLastSize) {\n\t\t\t\t\timg._pfLastSize = img.offsetWidth;\n\t\t\t\t\tsizes = img.sizes;\n\t\t\t\t\timg.sizes += \",100vw\";\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\timg.sizes = sizes;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar findPictureImgs = function() {\n\t\t\t\tvar i;\n\t\t\t\tvar imgs = document.querySelectorAll(\"picture > img, img[srcset][sizes]\");\n\t\t\t\tfor (i = 0; i < imgs.length; i++) {\n\t\t\t\t\tfixRespimg(imgs[i]);\n\t\t\t\t}\n\t\t\t};\n\t\t\tvar onResize = function() {\n\t\t\t\tclearTimeout(timer);\n\t\t\t\ttimer = setTimeout(findPictureImgs, 99);\n\t\t\t};\n\t\t\tvar mq = window.matchMedia && matchMedia(\"(orientation: landscape)\");\n\t\t\tvar init = function() {\n\t\t\t\tonResize();\n\n\t\t\t\tif (mq && mq.addListener) {\n\t\t\t\t\tmq.addListener(onResize);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tdummySrc.srcset = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\n\t\t\tif (/^[c|i]|d$/.test(document.readyState || \"\")) {\n\t\t\t\tinit();\n\t\t\t} else {\n\t\t\t\tdocument.addEventListener(\"DOMContentLoaded\", init);\n\t\t\t}\n\n\t\t\treturn onResize;\n\t\t})());\n\t}\n})(window);\n\n/*! Picturefill - v3.0.2\n * http://scottjehl.github.io/picturefill\n * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt;\n *  License: MIT\n */\n\n(function( window, document, undefined ) {\n\t// Enable strict mode\n\t\"use strict\";\n\n\t// HTML shim|v it for old IE (IE9 will still need the HTML video tag workaround)\n\tdocument.createElement( \"picture\" );\n\n\tvar warn, eminpx, alwaysCheckWDescriptor, evalId;\n\t// local object for method references and testing exposure\n\tvar pf = {};\n\tvar isSupportTestReady = false;\n\tvar noop = function() {};\n\tvar image = document.createElement( \"img\" );\n\tvar getImgAttr = image.getAttribute;\n\tvar setImgAttr = image.setAttribute;\n\tvar removeImgAttr = image.removeAttribute;\n\tvar docElem = document.documentElement;\n\tvar types = {};\n\tvar cfg = {\n\t\t//resource selection:\n\t\talgorithm: \"\"\n\t};\n\tvar srcAttr = \"data-pfsrc\";\n\tvar srcsetAttr = srcAttr + \"set\";\n\t// ua sniffing is done for undetectable img loading features,\n\t// to do some non crucial perf optimizations\n\tvar ua = navigator.userAgent;\n\tvar supportAbort = (/rident/).test(ua) || ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 > 35 );\n\tvar curSrcProp = \"currentSrc\";\n\tvar regWDesc = /\\s+\\+?\\d+(e\\d+)?w/;\n\tvar regSize = /(\\([^)]+\\))?\\s*(.+)/;\n\tvar setOptions = window.picturefillCFG;\n\t/**\n\t * Shortcut property for https://w3c.github.io/webappsec/specs/mixedcontent/#restricts-mixed-content ( for easy overriding in tests )\n\t */\n\t// baseStyle also used by getEmValue (i.e.: width: 1em is important)\n\tvar baseStyle = \"position:absolute;left:0;visibility:hidden;display:block;padding:0;border:none;font-size:1em;width:1em;overflow:hidden;clip:rect(0px, 0px, 0px, 0px)\";\n\tvar fsCss = \"font-size:100%!important;\";\n\tvar isVwDirty = true;\n\n\tvar cssCache = {};\n\tvar sizeLengthCache = {};\n\tvar DPR = window.devicePixelRatio;\n\tvar units = {\n\t\tpx: 1,\n\t\t\"in\": 96\n\t};\n\tvar anchor = document.createElement( \"a\" );\n\t/**\n\t * alreadyRun flag used for setOptions. is it true setOptions will reevaluate\n\t * @type {boolean}\n\t */\n\tvar alreadyRun = false;\n\n\t// Reusable, non-\"g\" Regexes\n\n\t// (Don't use \\s, to avoid matching non-breaking space.)\n\tvar regexLeadingSpaces = /^[ \\t\\n\\r\\u000c]+/,\n\t    regexLeadingCommasOrSpaces = /^[, \\t\\n\\r\\u000c]+/,\n\t    regexLeadingNotSpaces = /^[^ \\t\\n\\r\\u000c]+/,\n\t    regexTrailingCommas = /[,]+$/,\n\t    regexNonNegativeInteger = /^\\d+$/,\n\n\t    // ( Positive or negative or unsigned integers or decimals, without or without exponents.\n\t    // Must include at least one digit.\n\t    // According to spec tests any decimal point must be followed by a digit.\n\t    // No leading plus sign is allowed.)\n\t    // https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number\n\t    regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;\n\n\tvar on = function(obj, evt, fn, capture) {\n\t\tif ( obj.addEventListener ) {\n\t\t\tobj.addEventListener(evt, fn, capture || false);\n\t\t} else if ( obj.attachEvent ) {\n\t\t\tobj.attachEvent( \"on\" + evt, fn);\n\t\t}\n\t};\n\n\t/**\n\t * simple memoize function:\n\t */\n\n\tvar memoize = function(fn) {\n\t\tvar cache = {};\n\t\treturn function(input) {\n\t\t\tif ( !(input in cache) ) {\n\t\t\t\tcache[ input ] = fn(input);\n\t\t\t}\n\t\t\treturn cache[ input ];\n\t\t};\n\t};\n\n\t// UTILITY FUNCTIONS\n\n\t// Manual is faster than RegEx\n\t// http://jsperf.com/whitespace-character/5\n\tfunction isSpace(c) {\n\t\treturn (c === \"\\u0020\" || // space\n\t\t        c === \"\\u0009\" || // horizontal tab\n\t\t        c === \"\\u000A\" || // new line\n\t\t        c === \"\\u000C\" || // form feed\n\t\t        c === \"\\u000D\");  // carriage return\n\t}\n\n\t/**\n\t * gets a mediaquery and returns a boolean or gets a css length and returns a number\n\t * @param css mediaqueries or css length\n\t * @returns {boolean|number}\n\t *\n\t * based on: https://gist.github.com/jonathantneal/db4f77009b155f083738\n\t */\n\tvar evalCSS = (function() {\n\n\t\tvar regLength = /^([\\d\\.]+)(em|vw|px)$/;\n\t\tvar replace = function() {\n\t\t\tvar args = arguments, index = 0, string = args[0];\n\t\t\twhile (++index in args) {\n\t\t\t\tstring = string.replace(args[index], args[++index]);\n\t\t\t}\n\t\t\treturn string;\n\t\t};\n\n\t\tvar buildStr = memoize(function(css) {\n\n\t\t\treturn \"return \" + replace((css || \"\").toLowerCase(),\n\t\t\t\t// interpret `and`\n\t\t\t\t/\\band\\b/g, \"&&\",\n\n\t\t\t\t// interpret `,`\n\t\t\t\t/,/g, \"||\",\n\n\t\t\t\t// interpret `min-` as >=\n\t\t\t\t/min-([a-z-\\s]+):/g, \"e.$1>=\",\n\n\t\t\t\t// interpret `max-` as <=\n\t\t\t\t/max-([a-z-\\s]+):/g, \"e.$1<=\",\n\n\t\t\t\t//calc value\n\t\t\t\t/calc([^)]+)/g, \"($1)\",\n\n\t\t\t\t// interpret css values\n\t\t\t\t/(\\d+[\\.]*[\\d]*)([a-z]+)/g, \"($1 * e.$2)\",\n\t\t\t\t//make eval less evil\n\t\t\t\t/^(?!(e.[a-z]|[0-9\\.&=|><\\+\\-\\*\\(\\)\\/])).*/ig, \"\"\n\t\t\t) + \";\";\n\t\t});\n\n\t\treturn function(css, length) {\n\t\t\tvar parsedLength;\n\t\t\tif (!(css in cssCache)) {\n\t\t\t\tcssCache[css] = false;\n\t\t\t\tif (length && (parsedLength = css.match( regLength ))) {\n\t\t\t\t\tcssCache[css] = parsedLength[ 1 ] * units[parsedLength[ 2 ]];\n\t\t\t\t} else {\n\t\t\t\t\t/*jshint evil:true */\n\t\t\t\t\ttry{\n\t\t\t\t\t\tcssCache[css] = new Function(\"e\", buildStr(css))(units);\n\t\t\t\t\t} catch(e) {}\n\t\t\t\t\t/*jshint evil:false */\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn cssCache[css];\n\t\t};\n\t})();\n\n\tvar setResolution = function( candidate, sizesattr ) {\n\t\tif ( candidate.w ) { // h = means height: || descriptor.type === 'h' do not handle yet...\n\t\t\tcandidate.cWidth = pf.calcListLength( sizesattr || \"100vw\" );\n\t\t\tcandidate.res = candidate.w / candidate.cWidth ;\n\t\t} else {\n\t\t\tcandidate.res = candidate.d;\n\t\t}\n\t\treturn candidate;\n\t};\n\n\t/**\n\t *\n\t * @param opt\n\t */\n\tvar picturefill = function( opt ) {\n\n\t\tif (!isSupportTestReady) {return;}\n\n\t\tvar elements, i, plen;\n\n\t\tvar options = opt || {};\n\n\t\tif ( options.elements && options.elements.nodeType === 1 ) {\n\t\t\tif ( options.elements.nodeName.toUpperCase() === \"IMG\" ) {\n\t\t\t\toptions.elements =  [ options.elements ];\n\t\t\t} else {\n\t\t\t\toptions.context = options.elements;\n\t\t\t\toptions.elements =  null;\n\t\t\t}\n\t\t}\n\n\t\telements = options.elements || pf.qsa( (options.context || document), ( options.reevaluate || options.reselect ) ? pf.sel : pf.selShort );\n\n\t\tif ( (plen = elements.length) ) {\n\n\t\t\tpf.setupRun( options );\n\t\t\talreadyRun = true;\n\n\t\t\t// Loop through all elements\n\t\t\tfor ( i = 0; i < plen; i++ ) {\n\t\t\t\tpf.fillImg(elements[ i ], options);\n\t\t\t}\n\n\t\t\tpf.teardownRun( options );\n\t\t}\n\t};\n\n\t/**\n\t * outputs a warning for the developer\n\t * @param {message}\n\t * @type {Function}\n\t */\n\twarn = ( window.console && console.warn ) ?\n\t\tfunction( message ) {\n\t\t\tconsole.warn( message );\n\t\t} :\n\t\tnoop\n\t;\n\n\tif ( !(curSrcProp in image) ) {\n\t\tcurSrcProp = \"src\";\n\t}\n\n\t// Add support for standard mime types.\n\ttypes[ \"image/jpeg\" ] = true;\n\ttypes[ \"image/gif\" ] = true;\n\ttypes[ \"image/png\" ] = true;\n\n\tfunction detectTypeSupport( type, typeUri ) {\n\t\t// based on Modernizr's lossless img-webp test\n\t\t// note: asynchronous\n\t\tvar image = new window.Image();\n\t\timage.onerror = function() {\n\t\t\ttypes[ type ] = false;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.onload = function() {\n\t\t\ttypes[ type ] = image.width === 1;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.src = typeUri;\n\t\treturn \"pending\";\n\t}\n\n\t// test svg support\n\ttypes[ \"image/svg+xml\" ] = document.implementation.hasFeature( \"http://www.w3.org/TR/SVG11/feature#Image\", \"1.1\" );\n\n\t/**\n\t * updates the internal vW property with the current viewport width in px\n\t */\n\tfunction updateMetrics() {\n\n\t\tisVwDirty = false;\n\t\tDPR = window.devicePixelRatio;\n\t\tcssCache = {};\n\t\tsizeLengthCache = {};\n\n\t\tpf.DPR = DPR || 1;\n\n\t\tunits.width = Math.max(window.innerWidth || 0, docElem.clientWidth);\n\t\tunits.height = Math.max(window.innerHeight || 0, docElem.clientHeight);\n\n\t\tunits.vw = units.width / 100;\n\t\tunits.vh = units.height / 100;\n\n\t\tevalId = [ units.height, units.width, DPR ].join(\"-\");\n\n\t\tunits.em = pf.getEmValue();\n\t\tunits.rem = units.em;\n\t}\n\n\tfunction chooseLowRes( lowerValue, higherValue, dprValue, isCached ) {\n\t\tvar bonusFactor, tooMuch, bonus, meanDensity;\n\n\t\t//experimental\n\t\tif (cfg.algorithm === \"saveData\" ){\n\t\t\tif ( lowerValue > 2.7 ) {\n\t\t\t\tmeanDensity = dprValue + 1;\n\t\t\t} else {\n\t\t\t\ttooMuch = higherValue - dprValue;\n\t\t\t\tbonusFactor = Math.pow(lowerValue - 0.6, 1.5);\n\n\t\t\t\tbonus = tooMuch * bonusFactor;\n\n\t\t\t\tif (isCached) {\n\t\t\t\t\tbonus += 0.1 * bonusFactor;\n\t\t\t\t}\n\n\t\t\t\tmeanDensity = lowerValue + bonus;\n\t\t\t}\n\t\t} else {\n\t\t\tmeanDensity = (dprValue > 1) ?\n\t\t\t\tMath.sqrt(lowerValue * higherValue) :\n\t\t\t\tlowerValue;\n\t\t}\n\n\t\treturn meanDensity > dprValue;\n\t}\n\n\tfunction applyBestCandidate( img ) {\n\t\tvar srcSetCandidates;\n\t\tvar matchingSet = pf.getSet( img );\n\t\tvar evaluated = false;\n\t\tif ( matchingSet !== \"pending\" ) {\n\t\t\tevaluated = evalId;\n\t\t\tif ( matchingSet ) {\n\t\t\t\tsrcSetCandidates = pf.setRes( matchingSet );\n\t\t\t\tpf.applySetCandidate( srcSetCandidates, img );\n\t\t\t}\n\t\t}\n\t\timg[ pf.ns ].evaled = evaluated;\n\t}\n\n\tfunction ascendingSort( a, b ) {\n\t\treturn a.res - b.res;\n\t}\n\n\tfunction setSrcToCur( img, src, set ) {\n\t\tvar candidate;\n\t\tif ( !set && src ) {\n\t\t\tset = img[ pf.ns ].sets;\n\t\t\tset = set && set[set.length - 1];\n\t\t}\n\n\t\tcandidate = getCandidateForSrc(src, set);\n\n\t\tif ( candidate ) {\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\timg[ pf.ns ].curSrc = src;\n\t\t\timg[ pf.ns ].curCan = candidate;\n\n\t\t\tif ( !candidate.res ) {\n\t\t\t\tsetResolution( candidate, candidate.set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getCandidateForSrc( src, set ) {\n\t\tvar i, candidate, candidates;\n\t\tif ( src && set ) {\n\t\t\tcandidates = pf.parseSet( set );\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\tfor ( i = 0; i < candidates.length; i++ ) {\n\t\t\t\tif ( src === pf.makeUrl(candidates[ i ].url) ) {\n\t\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getAllSourceElements( picture, candidates ) {\n\t\tvar i, len, source, srcset;\n\n\t\t// SPEC mismatch intended for size and perf:\n\t\t// actually only source elements preceding the img should be used\n\t\t// also note: don't use qsa here, because IE8 sometimes doesn't like source as the key part in a selector\n\t\tvar sources = picture.getElementsByTagName( \"source\" );\n\n\t\tfor ( i = 0, len = sources.length; i < len; i++ ) {\n\t\t\tsource = sources[ i ];\n\t\t\tsource[ pf.ns ] = true;\n\t\t\tsrcset = source.getAttribute( \"srcset\" );\n\n\t\t\t// if source does not have a srcset attribute, skip\n\t\t\tif ( srcset ) {\n\t\t\t\tcandidates.push( {\n\t\t\t\t\tsrcset: srcset,\n\t\t\t\t\tmedia: source.getAttribute( \"media\" ),\n\t\t\t\t\ttype: source.getAttribute( \"type\" ),\n\t\t\t\t\tsizes: source.getAttribute( \"sizes\" )\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Srcset Parser\n\t * By Alex Bell |  MIT License\n\t *\n\t * @returns Array [{url: _, d: _, w: _, h:_, set:_(????)}, ...]\n\t *\n\t * Based super duper closely on the reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute\n\t */\n\n\t// 1. Let input be the value passed to this algorithm.\n\t// (TO-DO : Explain what \"set\" argument is here. Maybe choose a more\n\t// descriptive & more searchable name.  Since passing the \"set\" in really has\n\t// nothing to do with parsing proper, I would prefer this assignment eventually\n\t// go in an external fn.)\n\tfunction parseSrcset(input, set) {\n\n\t\tfunction collectCharacters(regEx) {\n\t\t\tvar chars,\n\t\t\t    match = regEx.exec(input.substring(pos));\n\t\t\tif (match) {\n\t\t\t\tchars = match[ 0 ];\n\t\t\t\tpos += chars.length;\n\t\t\t\treturn chars;\n\t\t\t}\n\t\t}\n\n\t\tvar inputLength = input.length,\n\t\t    url,\n\t\t    descriptors,\n\t\t    currentDescriptor,\n\t\t    state,\n\t\t    c,\n\n\t\t    // 2. Let position be a pointer into input, initially pointing at the start\n\t\t    //    of the string.\n\t\t    pos = 0,\n\n\t\t    // 3. Let candidates be an initially empty source set.\n\t\t    candidates = [];\n\n\t\t/**\n\t\t* Adds descriptor properties to a candidate, pushes to the candidates array\n\t\t* @return undefined\n\t\t*/\n\t\t// (Declared outside of the while loop so that it's only created once.\n\t\t// (This fn is defined before it is used, in order to pass JSHINT.\n\t\t// Unfortunately this breaks the sequencing of the spec comments. :/ )\n\t\tfunction parseDescriptors() {\n\n\t\t\t// 9. Descriptor parser: Let error be no.\n\t\t\tvar pError = false,\n\n\t\t\t// 10. Let width be absent.\n\t\t\t// 11. Let density be absent.\n\t\t\t// 12. Let future-compat-h be absent. (We're implementing it now as h)\n\t\t\t    w, d, h, i,\n\t\t\t    candidate = {},\n\t\t\t    desc, lastChar, value, intVal, floatVal;\n\n\t\t\t// 13. For each descriptor in descriptors, run the appropriate set of steps\n\t\t\t// from the following list:\n\t\t\tfor (i = 0 ; i < descriptors.length; i++) {\n\t\t\t\tdesc = descriptors[ i ];\n\n\t\t\t\tlastChar = desc[ desc.length - 1 ];\n\t\t\t\tvalue = desc.substring(0, desc.length - 1);\n\t\t\t\tintVal = parseInt(value, 10);\n\t\t\t\tfloatVal = parseFloat(value);\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0077 LATIN SMALL LETTER W character\n\t\t\t\tif (regexNonNegativeInteger.test(value) && (lastChar === \"w\")) {\n\n\t\t\t\t\t// If width and density are not both absent, then let error be yes.\n\t\t\t\t\tif (w || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes.\n\t\t\t\t\t// Otherwise, let width be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {w = intVal;}\n\n\t\t\t\t// If the descriptor consists of a valid floating-point number followed by\n\t\t\t\t// a U+0078 LATIN SMALL LETTER X character\n\t\t\t\t} else if (regexFloatingPoint.test(value) && (lastChar === \"x\")) {\n\n\t\t\t\t\t// If width, density and future-compat-h are not all absent, then let error\n\t\t\t\t\t// be yes.\n\t\t\t\t\tif (w || d || h) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing floating-point number values to the descriptor.\n\t\t\t\t\t// If the result is less than zero, let error be yes. Otherwise, let density\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (floatVal < 0) {pError = true;} else {d = floatVal;}\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0068 LATIN SMALL LETTER H character\n\t\t\t\t} else if (regexNonNegativeInteger.test(value) && (lastChar === \"h\")) {\n\n\t\t\t\t\t// If height and density are not both absent, then let error be yes.\n\t\t\t\t\tif (h || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes. Otherwise, let future-compat-h\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {h = intVal;}\n\n\t\t\t\t// Anything else, Let error be yes.\n\t\t\t\t} else {pError = true;}\n\t\t\t} // (close step 13 for loop)\n\n\t\t\t// 15. If error is still no, then append a new image source to candidates whose\n\t\t\t// URL is url, associated with a width width if not absent and a pixel\n\t\t\t// density density if not absent. Otherwise, there is a parse error.\n\t\t\tif (!pError) {\n\t\t\t\tcandidate.url = url;\n\n\t\t\t\tif (w) { candidate.w = w;}\n\t\t\t\tif (d) { candidate.d = d;}\n\t\t\t\tif (h) { candidate.h = h;}\n\t\t\t\tif (!h && !d && !w) {candidate.d = 1;}\n\t\t\t\tif (candidate.d === 1) {set.has1x = true;}\n\t\t\t\tcandidate.set = set;\n\n\t\t\t\tcandidates.push(candidate);\n\t\t\t}\n\t\t} // (close parseDescriptors fn)\n\n\t\t/**\n\t\t* Tokenizes descriptor properties prior to parsing\n\t\t* Returns undefined.\n\t\t* (Again, this fn is defined before it is used, in order to pass JSHINT.\n\t\t* Unfortunately this breaks the logical sequencing of the spec comments. :/ )\n\t\t*/\n\t\tfunction tokenize() {\n\n\t\t\t// 8.1. Descriptor tokeniser: Skip whitespace\n\t\t\tcollectCharacters(regexLeadingSpaces);\n\n\t\t\t// 8.2. Let current descriptor be the empty string.\n\t\t\tcurrentDescriptor = \"\";\n\n\t\t\t// 8.3. Let state be in descriptor.\n\t\t\tstate = \"in descriptor\";\n\n\t\t\twhile (true) {\n\n\t\t\t\t// 8.4. Let c be the character at position.\n\t\t\t\tc = input.charAt(pos);\n\n\t\t\t\t//  Do the following depending on the value of state.\n\t\t\t\t//  For the purpose of this step, \"EOF\" is a special character representing\n\t\t\t\t//  that position is past the end of input.\n\n\t\t\t\t// In descriptor\n\t\t\t\tif (state === \"in descriptor\") {\n\t\t\t\t\t// Do the following, depending on the value of c:\n\n\t\t\t\t  // Space character\n\t\t\t\t  // If current descriptor is not empty, append current descriptor to\n\t\t\t\t  // descriptors and let current descriptor be the empty string.\n\t\t\t\t  // Set state to after descriptor.\n\t\t\t\t\tif (isSpace(c)) {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t\tcurrentDescriptor = \"\";\n\t\t\t\t\t\t\tstate = \"after descriptor\";\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// U+002C COMMA (,)\n\t\t\t\t\t// Advance position to the next character in input. If current descriptor\n\t\t\t\t\t// is not empty, append current descriptor to descriptors. Jump to the step\n\t\t\t\t\t// labeled descriptor parser.\n\t\t\t\t\t} else if (c === \",\") {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// U+0028 LEFT PARENTHESIS (()\n\t\t\t\t\t// Append c to current descriptor. Set state to in parens.\n\t\t\t\t\t} else if (c === \"\\u0028\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in parens\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// If current descriptor is not empty, append current descriptor to\n\t\t\t\t\t// descriptors. Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\t\t\t\t// (end \"in descriptor\"\n\n\t\t\t\t// In parens\n\t\t\t\t} else if (state === \"in parens\") {\n\n\t\t\t\t\t// U+0029 RIGHT PARENTHESIS ())\n\t\t\t\t\t// Append c to current descriptor. Set state to in descriptor.\n\t\t\t\t\tif (c === \")\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in descriptor\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// Append current descriptor to descriptors. Jump to the step labeled\n\t\t\t\t\t// descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\n\t\t\t\t// After descriptor\n\t\t\t\t} else if (state === \"after descriptor\") {\n\n\t\t\t\t\t// Do the following, depending on the value of c:\n\t\t\t\t\t// Space character: Stay in this state.\n\t\t\t\t\tif (isSpace(c)) {\n\n\t\t\t\t\t// EOF: Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Set state to in descriptor. Set position to the previous character in input.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstate = \"in descriptor\";\n\t\t\t\t\t\tpos -= 1;\n\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Advance position to the next character in input.\n\t\t\t\tpos += 1;\n\n\t\t\t// Repeat this step.\n\t\t\t} // (close while true loop)\n\t\t}\n\n\t\t// 4. Splitting loop: Collect a sequence of characters that are space\n\t\t//    characters or U+002C COMMA characters. If any U+002C COMMA characters\n\t\t//    were collected, that is a parse error.\n\t\twhile (true) {\n\t\t\tcollectCharacters(regexLeadingCommasOrSpaces);\n\n\t\t\t// 5. If position is past the end of input, return candidates and abort these steps.\n\t\t\tif (pos >= inputLength) {\n\t\t\t\treturn candidates; // (we're done, this is the sole return path)\n\t\t\t}\n\n\t\t\t// 6. Collect a sequence of characters that are not space characters,\n\t\t\t//    and let that be url.\n\t\t\turl = collectCharacters(regexLeadingNotSpaces);\n\n\t\t\t// 7. Let descriptors be a new empty list.\n\t\t\tdescriptors = [];\n\n\t\t\t// 8. If url ends with a U+002C COMMA character (,), follow these substeps:\n\t\t\t//\t\t(1). Remove all trailing U+002C COMMA characters from url. If this removed\n\t\t\t//         more than one character, that is a parse error.\n\t\t\tif (url.slice(-1) === \",\") {\n\t\t\t\turl = url.replace(regexTrailingCommas, \"\");\n\t\t\t\t// (Jump ahead to step 9 to skip tokenization and just push the candidate).\n\t\t\t\tparseDescriptors();\n\n\t\t\t//\tOtherwise, follow these substeps:\n\t\t\t} else {\n\t\t\t\ttokenize();\n\t\t\t} // (close else of step 8)\n\n\t\t// 16. Return to the step labeled splitting loop.\n\t\t} // (Close of big while loop.)\n\t}\n\n\t/*\n\t * Sizes Parser\n\t *\n\t * By Alex Bell |  MIT License\n\t *\n\t * Non-strict but accurate and lightweight JS Parser for the string value <img sizes=\"here\">\n\t *\n\t * Reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-sizes-attribute\n\t *\n\t * Most comments are copied in directly from the spec\n\t * (except for comments in parens).\n\t *\n\t * Grammar is:\n\t * <source-size-list> = <source-size># [ , <source-size-value> ]? | <source-size-value>\n\t * <source-size> = <media-condition> <source-size-value>\n\t * <source-size-value> = <length>\n\t * http://www.w3.org/html/wg/drafts/html/master/embedded-content.html#attr-img-sizes\n\t *\n\t * E.g. \"(max-width: 30em) 100vw, (max-width: 50em) 70vw, 100vw\"\n\t * or \"(min-width: 30em), calc(30vw - 15px)\" or just \"30vw\"\n\t *\n\t * Returns the first valid <css-length> with a media condition that evaluates to true,\n\t * or \"100vw\" if all valid media conditions evaluate to false.\n\t *\n\t */\n\n\tfunction parseSizes(strValue) {\n\n\t\t// (Percentage CSS lengths are not allowed in this case, to avoid confusion:\n\t\t// https://html.spec.whatwg.org/multipage/embedded-content.html#valid-source-size-list\n\t\t// CSS allows a single optional plus or minus sign:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#numbers\n\t\t// CSS is ASCII case-insensitive:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#characters )\n\t\t// Spec allows exponential notation for <number> type:\n\t\t// http://dev.w3.org/csswg/css-values/#numbers\n\t\tvar regexCssLengthWithUnits = /^(?:[+-]?[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?(?:ch|cm|em|ex|in|mm|pc|pt|px|rem|vh|vmin|vmax|vw)$/i;\n\n\t\t// (This is a quick and lenient test. Because of optional unlimited-depth internal\n\t\t// grouping parens and strict spacing rules, this could get very complicated.)\n\t\tvar regexCssCalc = /^calc\\((?:[0-9a-z \\.\\+\\-\\*\\/\\(\\)]+)\\)$/i;\n\n\t\tvar i;\n\t\tvar unparsedSizesList;\n\t\tvar unparsedSizesListLength;\n\t\tvar unparsedSize;\n\t\tvar lastComponentValue;\n\t\tvar size;\n\n\t\t// UTILITY FUNCTIONS\n\n\t\t//  (Toy CSS parser. The goals here are:\n\t\t//  1) expansive test coverage without the weight of a full CSS parser.\n\t\t//  2) Avoiding regex wherever convenient.\n\t\t//  Quick tests: http://jsfiddle.net/gtntL4gr/3/\n\t\t//  Returns an array of arrays.)\n\t\tfunction parseComponentValues(str) {\n\t\t\tvar chrctr;\n\t\t\tvar component = \"\";\n\t\t\tvar componentArray = [];\n\t\t\tvar listArray = [];\n\t\t\tvar parenDepth = 0;\n\t\t\tvar pos = 0;\n\t\t\tvar inComment = false;\n\n\t\t\tfunction pushComponent() {\n\t\t\t\tif (component) {\n\t\t\t\t\tcomponentArray.push(component);\n\t\t\t\t\tcomponent = \"\";\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfunction pushComponentArray() {\n\t\t\t\tif (componentArray[0]) {\n\t\t\t\t\tlistArray.push(componentArray);\n\t\t\t\t\tcomponentArray = [];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// (Loop forwards from the beginning of the string.)\n\t\t\twhile (true) {\n\t\t\t\tchrctr = str.charAt(pos);\n\n\t\t\t\tif (chrctr === \"\") { // ( End of string reached.)\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\treturn listArray;\n\t\t\t\t} else if (inComment) {\n\t\t\t\t\tif ((chrctr === \"*\") && (str[pos + 1] === \"/\")) { // (At end of a comment.)\n\t\t\t\t\t\tinComment = false;\n\t\t\t\t\t\tpos += 2;\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tpos += 1; // (Skip all characters inside comments.)\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t} else if (isSpace(chrctr)) {\n\t\t\t\t\t// (If previous character in loop was also a space, or if\n\t\t\t\t\t// at the beginning of the string, do not add space char to\n\t\t\t\t\t// component.)\n\t\t\t\t\tif ( (str.charAt(pos - 1) && isSpace( str.charAt(pos - 1) ) ) || !component ) {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else if (parenDepth === 0) {\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tpos +=1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// (Replace any space character with a plain space for legibility.)\n\t\t\t\t\t\tchrctr = \" \";\n\t\t\t\t\t}\n\t\t\t\t} else if (chrctr === \"(\") {\n\t\t\t\t\tparenDepth += 1;\n\t\t\t\t} else if (chrctr === \")\") {\n\t\t\t\t\tparenDepth -= 1;\n\t\t\t\t} else if (chrctr === \",\") {\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\tpos += 1;\n\t\t\t\t\tcontinue;\n\t\t\t\t} else if ( (chrctr === \"/\") && (str.charAt(pos + 1) === \"*\") ) {\n\t\t\t\t\tinComment = true;\n\t\t\t\t\tpos += 2;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tcomponent = component + chrctr;\n\t\t\t\tpos += 1;\n\t\t\t}\n\t\t}\n\n\t\tfunction isValidNonNegativeSourceSizeValue(s) {\n\t\t\tif (regexCssLengthWithUnits.test(s) && (parseFloat(s) >= 0)) {return true;}\n\t\t\tif (regexCssCalc.test(s)) {return true;}\n\t\t\t// ( http://www.w3.org/TR/CSS2/syndata.html#numbers says:\n\t\t\t// \"-0 is equivalent to 0 and is not a negative number.\" which means that\n\t\t\t// unitless zero and unitless negative zero must be accepted as special cases.)\n\t\t\tif ((s === \"0\") || (s === \"-0\") || (s === \"+0\")) {return true;}\n\t\t\treturn false;\n\t\t}\n\n\t\t// When asked to parse a sizes attribute from an element, parse a\n\t\t// comma-separated list of component values from the value of the element's\n\t\t// sizes attribute (or the empty string, if the attribute is absent), and let\n\t\t// unparsed sizes list be the result.\n\t\t// http://dev.w3.org/csswg/css-syntax/#parse-comma-separated-list-of-component-values\n\n\t\tunparsedSizesList = parseComponentValues(strValue);\n\t\tunparsedSizesListLength = unparsedSizesList.length;\n\n\t\t// For each unparsed size in unparsed sizes list:\n\t\tfor (i = 0; i < unparsedSizesListLength; i++) {\n\t\t\tunparsedSize = unparsedSizesList[i];\n\n\t\t\t// 1. Remove all consecutive <whitespace-token>s from the end of unparsed size.\n\t\t\t// ( parseComponentValues() already omits spaces outside of parens. )\n\n\t\t\t// If unparsed size is now empty, that is a parse error; continue to the next\n\t\t\t// iteration of this algorithm.\n\t\t\t// ( parseComponentValues() won't push an empty array. )\n\n\t\t\t// 2. If the last component value in unparsed size is a valid non-negative\n\t\t\t// <source-size-value>, let size be its value and remove the component value\n\t\t\t// from unparsed size. Any CSS function other than the calc() function is\n\t\t\t// invalid. Otherwise, there is a parse error; continue to the next iteration\n\t\t\t// of this algorithm.\n\t\t\t// http://dev.w3.org/csswg/css-syntax/#parse-component-value\n\t\t\tlastComponentValue = unparsedSize[unparsedSize.length - 1];\n\n\t\t\tif (isValidNonNegativeSourceSizeValue(lastComponentValue)) {\n\t\t\t\tsize = lastComponentValue;\n\t\t\t\tunparsedSize.pop();\n\t\t\t} else {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 3. Remove all consecutive <whitespace-token>s from the end of unparsed\n\t\t\t// size. If unparsed size is now empty, return size and exit this algorithm.\n\t\t\t// If this was not the last item in unparsed sizes list, that is a parse error.\n\t\t\tif (unparsedSize.length === 0) {\n\t\t\t\treturn size;\n\t\t\t}\n\n\t\t\t// 4. Parse the remaining component values in unparsed size as a\n\t\t\t// <media-condition>. If it does not parse correctly, or it does parse\n\t\t\t// correctly but the <media-condition> evaluates to false, continue to the\n\t\t\t// next iteration of this algorithm.\n\t\t\t// (Parsing all possible compound media conditions in JS is heavy, complicated,\n\t\t\t// and the payoff is unclear. Is there ever an situation where the\n\t\t\t// media condition parses incorrectly but still somehow evaluates to true?\n\t\t\t// Can we just rely on the browser/polyfill to do it?)\n\t\t\tunparsedSize = unparsedSize.join(\" \");\n\t\t\tif (!(pf.matchesMedia( unparsedSize ) ) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 5. Return size and exit this algorithm.\n\t\t\treturn size;\n\t\t}\n\n\t\t// If the above algorithm exhausts unparsed sizes list without returning a\n\t\t// size value, return 100vw.\n\t\treturn \"100vw\";\n\t}\n\n\t// namespace\n\tpf.ns = (\"pf\" + new Date().getTime()).substr(0, 9);\n\n\t// srcset support test\n\tpf.supSrcset = \"srcset\" in image;\n\tpf.supSizes = \"sizes\" in image;\n\tpf.supPicture = !!window.HTMLPictureElement;\n\n\t// UC browser does claim to support srcset and picture, but not sizes,\n\t// this extended test reveals the browser does support nothing\n\tif (pf.supSrcset && pf.supPicture && !pf.supSizes) {\n\t\t(function(image2) {\n\t\t\timage.srcset = \"data:,a\";\n\t\t\timage2.src = \"data:,a\";\n\t\t\tpf.supSrcset = image.complete === image2.complete;\n\t\t\tpf.supPicture = pf.supSrcset && pf.supPicture;\n\t\t})(document.createElement(\"img\"));\n\t}\n\n\t// Safari9 has basic support for sizes, but does't expose the `sizes` idl attribute\n\tif (pf.supSrcset && !pf.supSizes) {\n\n\t\t(function() {\n\t\t\tvar width2 = \"data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw==\";\n\t\t\tvar width1 = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\t\t\tvar img = document.createElement(\"img\");\n\t\t\tvar test = function() {\n\t\t\t\tvar width = img.width;\n\n\t\t\t\tif (width === 2) {\n\t\t\t\t\tpf.supSizes = true;\n\t\t\t\t}\n\n\t\t\t\talwaysCheckWDescriptor = pf.supSrcset && !pf.supSizes;\n\n\t\t\t\tisSupportTestReady = true;\n\t\t\t\t// force async\n\t\t\t\tsetTimeout(picturefill);\n\t\t\t};\n\n\t\t\timg.onload = test;\n\t\t\timg.onerror = test;\n\t\t\timg.setAttribute(\"sizes\", \"9px\");\n\n\t\t\timg.srcset = width1 + \" 1w,\" + width2 + \" 9w\";\n\t\t\timg.src = width1;\n\t\t})();\n\n\t} else {\n\t\tisSupportTestReady = true;\n\t}\n\n\t// using pf.qsa instead of dom traversing does scale much better,\n\t// especially on sites mixing responsive and non-responsive images\n\tpf.selShort = \"picture>img,img[srcset]\";\n\tpf.sel = pf.selShort;\n\tpf.cfg = cfg;\n\n\t/**\n\t * Shortcut property for `devicePixelRatio` ( for easy overriding in tests )\n\t */\n\tpf.DPR = (DPR  || 1 );\n\tpf.u = units;\n\n\t// container of supported mime types that one might need to qualify before using\n\tpf.types =  types;\n\n\tpf.setSize = noop;\n\n\t/**\n\t * Gets a string and returns the absolute URL\n\t * @param src\n\t * @returns {String} absolute URL\n\t */\n\n\tpf.makeUrl = memoize(function(src) {\n\t\tanchor.href = src;\n\t\treturn anchor.href;\n\t});\n\n\t/**\n\t * Gets a DOM element or document and a selctor and returns the found matches\n\t * Can be extended with jQuery/Sizzle for IE7 support\n\t * @param context\n\t * @param sel\n\t * @returns {NodeList|Array}\n\t */\n\tpf.qsa = function(context, sel) {\n\t\treturn ( \"querySelector\" in context ) ? context.querySelectorAll(sel) : [];\n\t};\n\n\t/**\n\t * Shortcut method for matchMedia ( for easy overriding in tests )\n\t * wether native or pf.mMQ is used will be decided lazy on first call\n\t * @returns {boolean}\n\t */\n\tpf.matchesMedia = function() {\n\t\tif ( window.matchMedia && (matchMedia( \"(min-width: 0.1em)\" ) || {}).matches ) {\n\t\t\tpf.matchesMedia = function( media ) {\n\t\t\t\treturn !media || ( matchMedia( media ).matches );\n\t\t\t};\n\t\t} else {\n\t\t\tpf.matchesMedia = pf.mMQ;\n\t\t}\n\n\t\treturn pf.matchesMedia.apply( this, arguments );\n\t};\n\n\t/**\n\t * A simplified matchMedia implementation for IE8 and IE9\n\t * handles only min-width/max-width with px or em values\n\t * @param media\n\t * @returns {boolean}\n\t */\n\tpf.mMQ = function( media ) {\n\t\treturn media ? evalCSS(media) : true;\n\t};\n\n\t/**\n\t * Returns the calculated length in css pixel from the given sourceSizeValue\n\t * http://dev.w3.org/csswg/css-values-3/#length-value\n\t * intended Spec mismatches:\n\t * * Does not check for invalid use of CSS functions\n\t * * Does handle a computed length of 0 the same as a negative and therefore invalid value\n\t * @param sourceSizeValue\n\t * @returns {Number}\n\t */\n\tpf.calcLength = function( sourceSizeValue ) {\n\n\t\tvar value = evalCSS(sourceSizeValue, true) || false;\n\t\tif (value < 0) {\n\t\t\tvalue = false;\n\t\t}\n\n\t\treturn value;\n\t};\n\n\t/**\n\t * Takes a type string and checks if its supported\n\t */\n\n\tpf.supportsType = function( type ) {\n\t\treturn ( type ) ? types[ type ] : true;\n\t};\n\n\t/**\n\t * Parses a sourceSize into mediaCondition (media) and sourceSizeValue (length)\n\t * @param sourceSizeStr\n\t * @returns {*}\n\t */\n\tpf.parseSize = memoize(function( sourceSizeStr ) {\n\t\tvar match = ( sourceSizeStr || \"\" ).match(regSize);\n\t\treturn {\n\t\t\tmedia: match && match[1],\n\t\t\tlength: match && match[2]\n\t\t};\n\t});\n\n\tpf.parseSet = function( set ) {\n\t\tif ( !set.cands ) {\n\t\t\tset.cands = parseSrcset(set.srcset, set);\n\t\t}\n\t\treturn set.cands;\n\t};\n\n\t/**\n\t * returns 1em in css px for html/body default size\n\t * function taken from respondjs\n\t * @returns {*|number}\n\t */\n\tpf.getEmValue = function() {\n\t\tvar body;\n\t\tif ( !eminpx && (body = document.body) ) {\n\t\t\tvar div = document.createElement( \"div\" ),\n\t\t\t\toriginalHTMLCSS = docElem.style.cssText,\n\t\t\t\toriginalBodyCSS = body.style.cssText;\n\n\t\t\tdiv.style.cssText = baseStyle;\n\n\t\t\t// 1em in a media query is the value of the default font size of the browser\n\t\t\t// reset docElem and body to ensure the correct value is returned\n\t\t\tdocElem.style.cssText = fsCss;\n\t\t\tbody.style.cssText = fsCss;\n\n\t\t\tbody.appendChild( div );\n\t\t\teminpx = div.offsetWidth;\n\t\t\tbody.removeChild( div );\n\n\t\t\t//also update eminpx before returning\n\t\t\teminpx = parseFloat( eminpx, 10 );\n\n\t\t\t// restore the original values\n\t\t\tdocElem.style.cssText = originalHTMLCSS;\n\t\t\tbody.style.cssText = originalBodyCSS;\n\n\t\t}\n\t\treturn eminpx || 16;\n\t};\n\n\t/**\n\t * Takes a string of sizes and returns the width in pixels as a number\n\t */\n\tpf.calcListLength = function( sourceSizeListStr ) {\n\t\t// Split up source size list, ie ( max-width: 30em ) 100%, ( max-width: 50em ) 50%, 33%\n\t\t//\n\t\t//                           or (min-width:30em) calc(30% - 15px)\n\t\tif ( !(sourceSizeListStr in sizeLengthCache) || cfg.uT ) {\n\t\t\tvar winningLength = pf.calcLength( parseSizes( sourceSizeListStr ) );\n\n\t\t\tsizeLengthCache[ sourceSizeListStr ] = !winningLength ? units.width : winningLength;\n\t\t}\n\n\t\treturn sizeLengthCache[ sourceSizeListStr ];\n\t};\n\n\t/**\n\t * Takes a candidate object with a srcset property in the form of url/\n\t * ex. \"images/pic-medium.png 1x, images/pic-medium-2x.png 2x\" or\n\t *     \"images/pic-medium.png 400w, images/pic-medium-2x.png 800w\" or\n\t *     \"images/pic-small.png\"\n\t * Get an array of image candidates in the form of\n\t *      {url: \"/foo/bar.png\", resolution: 1}\n\t * where resolution is http://dev.w3.org/csswg/css-values-3/#resolution-value\n\t * If sizes is specified, res is calculated\n\t */\n\tpf.setRes = function( set ) {\n\t\tvar candidates;\n\t\tif ( set ) {\n\n\t\t\tcandidates = pf.parseSet( set );\n\n\t\t\tfor ( var i = 0, len = candidates.length; i < len; i++ ) {\n\t\t\t\tsetResolution( candidates[ i ], set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidates;\n\t};\n\n\tpf.setRes.res = setResolution;\n\n\tpf.applySetCandidate = function( candidates, img ) {\n\t\tif ( !candidates.length ) {return;}\n\t\tvar candidate,\n\t\t\ti,\n\t\t\tj,\n\t\t\tlength,\n\t\t\tbestCandidate,\n\t\t\tcurSrc,\n\t\t\tcurCan,\n\t\t\tcandidateSrc,\n\t\t\tabortCurSrc;\n\n\t\tvar imageData = img[ pf.ns ];\n\t\tvar dpr = pf.DPR;\n\n\t\tcurSrc = imageData.curSrc || img[curSrcProp];\n\n\t\tcurCan = imageData.curCan || setSrcToCur(img, curSrc, candidates[0].set);\n\n\t\t// if we have a current source, we might either become lazy or give this source some advantage\n\t\tif ( curCan && curCan.set === candidates[ 0 ].set ) {\n\n\t\t\t// if browser can abort image request and the image has a higher pixel density than needed\n\t\t\t// and this image isn't downloaded yet, we skip next part and try to save bandwidth\n\t\t\tabortCurSrc = (supportAbort && !img.complete && curCan.res - 0.1 > dpr);\n\n\t\t\tif ( !abortCurSrc ) {\n\t\t\t\tcurCan.cached = true;\n\n\t\t\t\t// if current candidate is \"best\", \"better\" or \"okay\",\n\t\t\t\t// set it to bestCandidate\n\t\t\t\tif ( curCan.res >= dpr ) {\n\t\t\t\t\tbestCandidate = curCan;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( !bestCandidate ) {\n\n\t\t\tcandidates.sort( ascendingSort );\n\n\t\t\tlength = candidates.length;\n\t\t\tbestCandidate = candidates[ length - 1 ];\n\n\t\t\tfor ( i = 0; i < length; i++ ) {\n\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\tif ( candidate.res >= dpr ) {\n\t\t\t\t\tj = i - 1;\n\n\t\t\t\t\t// we have found the perfect candidate,\n\t\t\t\t\t// but let's improve this a little bit with some assumptions ;-)\n\t\t\t\t\tif (candidates[ j ] &&\n\t\t\t\t\t\t(abortCurSrc || curSrc !== pf.makeUrl( candidate.url )) &&\n\t\t\t\t\t\tchooseLowRes(candidates[ j ].res, candidate.res, dpr, candidates[ j ].cached)) {\n\n\t\t\t\t\t\tbestCandidate = candidates[ j ];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbestCandidate = candidate;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( bestCandidate ) {\n\n\t\t\tcandidateSrc = pf.makeUrl( bestCandidate.url );\n\n\t\t\timageData.curSrc = candidateSrc;\n\t\t\timageData.curCan = bestCandidate;\n\n\t\t\tif ( candidateSrc !== curSrc ) {\n\t\t\t\tpf.setSrc( img, bestCandidate );\n\t\t\t}\n\t\t\tpf.setSize( img );\n\t\t}\n\t};\n\n\tpf.setSrc = function( img, bestCandidate ) {\n\t\tvar origWidth;\n\t\timg.src = bestCandidate.url;\n\n\t\t// although this is a specific Safari issue, we don't want to take too much different code paths\n\t\tif ( bestCandidate.set.type === \"image/svg+xml\" ) {\n\t\t\torigWidth = img.style.width;\n\t\t\timg.style.width = (img.offsetWidth + 1) + \"px\";\n\n\t\t\t// next line only should trigger a repaint\n\t\t\t// if... is only done to trick dead code removal\n\t\t\tif ( img.offsetWidth + 1 ) {\n\t\t\t\timg.style.width = origWidth;\n\t\t\t}\n\t\t}\n\t};\n\n\tpf.getSet = function( img ) {\n\t\tvar i, set, supportsType;\n\t\tvar match = false;\n\t\tvar sets = img [ pf.ns ].sets;\n\n\t\tfor ( i = 0; i < sets.length && !match; i++ ) {\n\t\t\tset = sets[i];\n\n\t\t\tif ( !set.srcset || !pf.matchesMedia( set.media ) || !(supportsType = pf.supportsType( set.type )) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif ( supportsType === \"pending\" ) {\n\t\t\t\tset = supportsType;\n\t\t\t}\n\n\t\t\tmatch = set;\n\t\t\tbreak;\n\t\t}\n\n\t\treturn match;\n\t};\n\n\tpf.parseSets = function( element, parent, options ) {\n\t\tvar srcsetAttribute, imageSet, isWDescripor, srcsetParsed;\n\n\t\tvar hasPicture = parent && parent.nodeName.toUpperCase() === \"PICTURE\";\n\t\tvar imageData = element[ pf.ns ];\n\n\t\tif ( imageData.src === undefined || options.src ) {\n\t\t\timageData.src = getImgAttr.call( element, \"src\" );\n\t\t\tif ( imageData.src ) {\n\t\t\t\tsetImgAttr.call( element, srcAttr, imageData.src );\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcAttr );\n\t\t\t}\n\t\t}\n\n\t\tif ( imageData.srcset === undefined || options.srcset || !pf.supSrcset || element.srcset ) {\n\t\t\tsrcsetAttribute = getImgAttr.call( element, \"srcset\" );\n\t\t\timageData.srcset = srcsetAttribute;\n\t\t\tsrcsetParsed = true;\n\t\t}\n\n\t\timageData.sets = [];\n\n\t\tif ( hasPicture ) {\n\t\t\timageData.pic = true;\n\t\t\tgetAllSourceElements( parent, imageData.sets );\n\t\t}\n\n\t\tif ( imageData.srcset ) {\n\t\t\timageSet = {\n\t\t\t\tsrcset: imageData.srcset,\n\t\t\t\tsizes: getImgAttr.call( element, \"sizes\" )\n\t\t\t};\n\n\t\t\timageData.sets.push( imageSet );\n\n\t\t\tisWDescripor = (alwaysCheckWDescriptor || imageData.src) && regWDesc.test(imageData.srcset || \"\");\n\n\t\t\t// add normal src as candidate, if source has no w descriptor\n\t\t\tif ( !isWDescripor && imageData.src && !getCandidateForSrc(imageData.src, imageSet) && !imageSet.has1x ) {\n\t\t\t\timageSet.srcset += \", \" + imageData.src;\n\t\t\t\timageSet.cands.push({\n\t\t\t\t\turl: imageData.src,\n\t\t\t\t\td: 1,\n\t\t\t\t\tset: imageSet\n\t\t\t\t});\n\t\t\t}\n\n\t\t} else if ( imageData.src ) {\n\t\t\timageData.sets.push( {\n\t\t\t\tsrcset: imageData.src,\n\t\t\t\tsizes: null\n\t\t\t} );\n\t\t}\n\n\t\timageData.curCan = null;\n\t\timageData.curSrc = undefined;\n\n\t\t// if img has picture or the srcset was removed or has a srcset and does not support srcset at all\n\t\t// or has a w descriptor (and does not support sizes) set support to false to evaluate\n\t\timageData.supported = !( hasPicture || ( imageSet && !pf.supSrcset ) || (isWDescripor && !pf.supSizes) );\n\n\t\tif ( srcsetParsed && pf.supSrcset && !imageData.supported ) {\n\t\t\tif ( srcsetAttribute ) {\n\t\t\t\tsetImgAttr.call( element, srcsetAttr, srcsetAttribute );\n\t\t\t\telement.srcset = \"\";\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcsetAttr );\n\t\t\t}\n\t\t}\n\n\t\tif (imageData.supported && !imageData.srcset && ((!imageData.src && element.src) ||  element.src !== pf.makeUrl(imageData.src))) {\n\t\t\tif (imageData.src === null) {\n\t\t\t\telement.removeAttribute(\"src\");\n\t\t\t} else {\n\t\t\t\telement.src = imageData.src;\n\t\t\t}\n\t\t}\n\n\t\timageData.parsed = true;\n\t};\n\n\tpf.fillImg = function(element, options) {\n\t\tvar imageData;\n\t\tvar extreme = options.reselect || options.reevaluate;\n\n\t\t// expando for caching data on the img\n\t\tif ( !element[ pf.ns ] ) {\n\t\t\telement[ pf.ns ] = {};\n\t\t}\n\n\t\timageData = element[ pf.ns ];\n\n\t\t// if the element has already been evaluated, skip it\n\t\t// unless `options.reevaluate` is set to true ( this, for example,\n\t\t// is set to true when running `picturefill` on `resize` ).\n\t\tif ( !extreme && imageData.evaled === evalId ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( !imageData.parsed || options.reevaluate ) {\n\t\t\tpf.parseSets( element, element.parentNode, options );\n\t\t}\n\n\t\tif ( !imageData.supported ) {\n\t\t\tapplyBestCandidate( element );\n\t\t} else {\n\t\t\timageData.evaled = evalId;\n\t\t}\n\t};\n\n\tpf.setupRun = function() {\n\t\tif ( !alreadyRun || isVwDirty || (DPR !== window.devicePixelRatio) ) {\n\t\t\tupdateMetrics();\n\t\t}\n\t};\n\n\t// If picture is supported, well, that's awesome.\n\tif ( pf.supPicture ) {\n\t\tpicturefill = noop;\n\t\tpf.fillImg = noop;\n\t} else {\n\n\t\t // Set up picture polyfill by polling the document\n\t\t(function() {\n\t\t\tvar isDomReady;\n\t\t\tvar regReady = window.attachEvent ? /d$|^c/ : /d$|^c|^i/;\n\n\t\t\tvar run = function() {\n\t\t\t\tvar readyState = document.readyState || \"\";\n\n\t\t\t\ttimerId = setTimeout(run, readyState === \"loading\" ? 200 :  999);\n\t\t\t\tif ( document.body ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t\tisDomReady = isDomReady || regReady.test(readyState);\n\t\t\t\t\tif ( isDomReady ) {\n\t\t\t\t\t\tclearTimeout( timerId );\n\t\t\t\t\t}\n\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar timerId = setTimeout(run, document.body ? 9 : 99);\n\n\t\t\t// Also attach picturefill on resize and readystatechange\n\t\t\t// http://modernjavascript.blogspot.com/2013/08/building-better-debounce.html\n\t\t\tvar debounce = function(func, wait) {\n\t\t\t\tvar timeout, timestamp;\n\t\t\t\tvar later = function() {\n\t\t\t\t\tvar last = (new Date()) - timestamp;\n\n\t\t\t\t\tif (last < wait) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait - last);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttimeout = null;\n\t\t\t\t\t\tfunc();\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\treturn function() {\n\t\t\t\t\ttimestamp = new Date();\n\n\t\t\t\t\tif (!timeout) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\t\t\tvar lastClientWidth = docElem.clientHeight;\n\t\t\tvar onResize = function() {\n\t\t\t\tisVwDirty = Math.max(window.innerWidth || 0, docElem.clientWidth) !== units.width || docElem.clientHeight !== lastClientWidth;\n\t\t\t\tlastClientWidth = docElem.clientHeight;\n\t\t\t\tif ( isVwDirty ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t}\n\t\t\t};\n\n\t\t\ton( window, \"resize\", debounce(onResize, 99 ) );\n\t\t\ton( document, \"readystatechange\", run );\n\t\t})();\n\t}\n\n\tpf.picturefill = picturefill;\n\t//use this internally for easy monkey patching/performance testing\n\tpf.fillImgs = picturefill;\n\tpf.teardownRun = noop;\n\n\t/* expose methods for testing */\n\tpicturefill._ = pf;\n\n\twindow.picturefillCFG = {\n\t\tpf: pf,\n\t\tpush: function(args) {\n\t\t\tvar name = args.shift();\n\t\t\tif (typeof pf[name] === \"function\") {\n\t\t\t\tpf[name].apply(pf, args);\n\t\t\t} else {\n\t\t\t\tcfg[name] = args[0];\n\t\t\t\tif (alreadyRun) {\n\t\t\t\t\tpf.fillImgs( { reselect: true } );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\twhile (setOptions && setOptions.length) {\n\t\twindow.picturefillCFG.push(setOptions.shift());\n\t}\n\n\t/* expose picturefill */\n\twindow.picturefill = picturefill;\n\n\t/* expose picturefill */\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// CommonJS, just export\n\t\tmodule.exports = picturefill;\n\t} else if ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD support\n\t\tdefine( \"picturefill\", function() { return picturefill; } );\n\t}\n\n\t// IE8 evals this sync, so it must be the last thing we do\n\tif ( !pf.supPicture ) {\n\t\ttypes[ \"image/webp\" ] = detectTypeSupport(\"image/webp\", \"data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==\" );\n\t}\n\n} )( window, document );\n"],"sourceRoot":""}
//# sourceURL=webpack-internal:///7229

/** @license React v17.0.1
 * react-dom.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
/*
 Modernizr 3.0.0pre (Custom Build) | MIT
*/
var aa = __webpack_require__(7294),
    m = __webpack_require__(7418),
    r = __webpack_require__(3840);

function y(a) {
    for (var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length; c++) b += "&args[]=" + encodeURIComponent(arguments[c]);
    return "Minified React error #" + a + "; visit " + b + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."
}
if (!aa) throw Error(y(227));
var ba = new Set,
    ca = {};

function da(a, b) {
    ea(a, b);
    ea(a + "Capture", b)
}

function ea(a, b) {
    ca[a] = b;
    for (a = 0; a < b.length; a++) ba.add(b[a])
}
var fa = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement),
    ha = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,
    ia = Object.prototype.hasOwnProperty,
    ja = {},
    ka = {};

function la(a) {
    if (ia.call(ka, a)) return !0;
    if (ia.call(ja, a)) return !1;
    if (ha.test(a)) return ka[a] = !0;
    ja[a] = !0;
    return !1
}

function ma(a, b, c, d) {
    if (null !== c && 0 === c.type) return !1;
    switch (typeof b) {
        case "function":
        case "symbol":
            return !0;
        case "boolean":
            if (d) return !1;
            if (null !== c) return !c.acceptsBooleans;
            a = a.toLowerCase().slice(0, 5);
            return "data-" !== a && "aria-" !== a;
        default:
            return !1
    }
}

function na(a, b, c, d) {
    if (null === b || "undefined" === typeof b || ma(a, b, c, d)) return !0;
    if (d) return !1;
    if (null !== c) switch (c.type) {
        case 3:
            return !b;
        case 4:
            return !1 === b;
        case 5:
            return isNaN(b);
        case 6:
            return isNaN(b) || 1 > b
    }
    return !1
}

function B(a, b, c, d, e, f, g) {
    this.acceptsBooleans = 2 === b || 3 === b || 4 === b;
    this.attributeName = d;
    this.attributeNamespace = e;
    this.mustUseProperty = c;
    this.propertyName = a;
    this.type = b;
    this.sanitizeURL = f;
    this.removeEmptyString = g
}
var D = {};
"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a) {
    D[a] = new B(a, 0, !1, a, null, !1, !1)
});
[
    ["acceptCharset", "accept-charset"],
    ["className", "class"],
    ["htmlFor", "for"],
    ["httpEquiv", "http-equiv"]
].forEach(function(a) {
    var b = a[0];
    D[b] = new B(b, 1, !1, a[1], null, !1, !1)
});
["contentEditable", "draggable", "spellCheck", "value"].forEach(function(a) {
    D[a] = new B(a, 2, !1, a.toLowerCase(), null, !1, !1)
});
["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"].forEach(function(a) {
    D[a] = new B(a, 2, !1, a, null, !1, !1)
});
"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a) {
    D[a] = new B(a, 3, !1, a.toLowerCase(), null, !1, !1)
});
["checked", "multiple", "muted", "selected"].forEach(function(a) {
    D[a] = new B(a, 3, !0, a, null, !1, !1)
});
["capture", "download"].forEach(function(a) {
    D[a] = new B(a, 4, !1, a, null, !1, !1)
});
["cols", "rows", "size", "span"].forEach(function(a) {
    D[a] = new B(a, 6, !1, a, null, !1, !1)
});
["rowSpan", "start"].forEach(function(a) {
    D[a] = new B(a, 5, !1, a.toLowerCase(), null, !1, !1)
});
var oa = /[\-:]([a-z])/g;

function pa(a) {
    return a[1].toUpperCase()
}
"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a) {
    var b = a.replace(oa,
        pa);
    D[b] = new B(b, 1, !1, a, null, !1, !1)
});
"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a) {
    var b = a.replace(oa, pa);
    D[b] = new B(b, 1, !1, a, "http://www.w3.org/1999/xlink", !1, !1)
});
["xml:base", "xml:lang", "xml:space"].forEach(function(a) {
    var b = a.replace(oa, pa);
    D[b] = new B(b, 1, !1, a, "http://www.w3.org/XML/1998/namespace", !1, !1)
});
["tabIndex", "crossOrigin"].forEach(function(a) {
    D[a] = new B(a, 1, !1, a.toLowerCase(), null, !1, !1)
});
D.xlinkHref = new B("xlinkHref", 1, !1, "xlink:href", "http://www.w3.org/1999/xlink", !0, !1);
["src", "href", "action", "formAction"].forEach(function(a) {
    D[a] = new B(a, 1, !1, a.toLowerCase(), null, !0, !0)
});

function qa(a, b, c, d) {
    var e = D.hasOwnProperty(b) ? D[b] : null;
    var f = null !== e ? 0 === e.type : d ? !1 : !(2 < b.length) || "o" !== b[0] && "O" !== b[0] || "n" !== b[1] && "N" !== b[1] ? !1 : !0;
    f || (na(b, c, e, d) && (c = null), d || null === e ? la(b) && (null === c ? a.removeAttribute(b) : a.setAttribute(b, "" + c)) : e.mustUseProperty ? a[e.propertyName] = null === c ? 3 === e.type ? !1 : "" : c : (b = e.attributeName, d = e.attributeNamespace, null === c ? a.removeAttribute(b) : (e = e.type, c = 3 === e || 4 === e && !0 === c ? "" : "" + c, d ? a.setAttributeNS(d, b, c) : a.setAttribute(b, c))))
}
var ra = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
    sa = 60103,
    ta = 60106,
    ua = 60107,
    wa = 60108,
    xa = 60114,
    ya = 60109,
    za = 60110,
    Aa = 60112,
    Ba = 60113,
    Ca = 60120,
    Da = 60115,
    Ea = 60116,
    Fa = 60121,
    Ga = 60128,
    Ha = 60129,
    Ia = 60130,
    Ja = 60131;
if ("function" === typeof Symbol && Symbol.for) {
    var E = Symbol.for;
    sa = E("react.element");
    ta = E("react.portal");
    ua = E("react.fragment");
    wa = E("react.strict_mode");
    xa = E("react.profiler");
    ya = E("react.provider");
    za = E("react.context");
    Aa = E("react.forward_ref");
    Ba = E("react.suspense");
    Ca = E("react.suspense_list");
    Da = E("react.memo");
    Ea = E("react.lazy");
    Fa = E("react.block");
    E("react.scope");
    Ga = E("react.opaque.id");
    Ha = E("react.debug_trace_mode");
    Ia = E("react.offscreen");
    Ja = E("react.legacy_hidden")
}
var Ka = "function" === typeof Symbol && Symbol.iterator;

function La(a) {
    if (null === a || "object" !== typeof a) return null;
    a = Ka && a[Ka] || a["@@iterator"];
    return "function" === typeof a ? a : null
}
var Ma;

function Na(a) {
    if (void 0 === Ma) try {
        throw Error();
    } catch (c) {
        var b = c.stack.trim().match(/\n( *(at )?)/);
        Ma = b && b[1] || ""
    }
    return "\n" + Ma + a
}
var Oa = !1;

function Pa(a, b) {
    if (!a || Oa) return "";
    Oa = !0;
    var c = Error.prepareStackTrace;
    Error.prepareStackTrace = void 0;
    try {
        if (b)
            if (b = function() {
                    throw Error();
                }, Object.defineProperty(b.prototype, "props", {set: function() {
                        throw Error();
                    }
                }), "object" === typeof Reflect && Reflect.construct) {
                try {
                    Reflect.construct(b, [])
                } catch (k) {
                    var d = k
                }
                Reflect.construct(a, [], b)
            } else {
                try {
                    b.call()
                } catch (k) {
                    d = k
                }
                a.call(b.prototype)
            } else {
            try {
                throw Error();
            } catch (k) {
                d = k
            }
            a()
        }
    } catch (k) {
        if (k && d && "string" === typeof k.stack) {
            for (var e = k.stack.split("\n"),
                    f = d.stack.split("\n"), g = e.length - 1, h = f.length - 1; 1 <= g && 0 <= h && e[g] !== f[h];) h--;
            for (; 1 <= g && 0 <= h; g--, h--)
                if (e[g] !== f[h]) {
                    if (1 !== g || 1 !== h) {
                        do
                            if (g--, h--, 0 > h || e[g] !== f[h]) return "\n" + e[g].replace(" at new ", " at ");
                        while (1 <= g && 0 <= h)
                    }
                    break
                }
        }
    } finally {
        Oa = !1, Error.prepareStackTrace = c
    }
    return (a = a ? a.displayName || a.name : "") ? Na(a) : ""
}

function Qa(a) {
    switch (a.tag) {
        case 5:
            return Na(a.type);
        case 16:
            return Na("Lazy");
        case 13:
            return Na("Suspense");
        case 19:
            return Na("SuspenseList");
        case 0:
        case 2:
        case 15:
            return a = Pa(a.type, !1), a;
        case 11:
            return a = Pa(a.type.render, !1), a;
        case 22:
            return a = Pa(a.type._render, !1), a;
        case 1:
            return a = Pa(a.type, !0), a;
        default:
            return ""
    }
}

function Ra(a) {
    if (null == a) return null;
    if ("function" === typeof a) return a.displayName || a.name || null;
    if ("string" === typeof a) return a;
    switch (a) {
        case ua:
            return "Fragment";
        case ta:
            return "Portal";
        case xa:
            return "Profiler";
        case wa:
            return "StrictMode";
        case Ba:
            return "Suspense";
        case Ca:
            return "SuspenseList"
    }
    if ("object" === typeof a) switch (a.$$typeof) {
        case za:
            return (a.displayName || "Context") + ".Consumer";
        case ya:
            return (a._context.displayName || "Context") + ".Provider";
        case Aa:
            var b = a.render;
            b = b.displayName || b.name || "";
            return a.displayName || ("" !== b ? "ForwardRef(" + b + ")" : "ForwardRef");
        case Da:
            return Ra(a.type);
        case Fa:
            return Ra(a._render);
        case Ea:
            b = a._payload;
            a = a._init;
            try {
                return Ra(a(b))
            } catch (c) {}
    }
    return null
}

function Sa(a) {
    switch (typeof a) {
        case "boolean":
        case "number":
        case "object":
        case "string":
        case "undefined":
            return a;
        default:
            return ""
    }
}

function Ta(a) {
    var b = a.type;
    return (a = a.nodeName) && "input" === a.toLowerCase() && ("checkbox" === b || "radio" === b)
}

function Ua(a) {
    var b = Ta(a) ? "checked" : "value",
        c = Object.getOwnPropertyDescriptor(a.constructor.prototype, b),
        d = "" + a[b];
    if (!a.hasOwnProperty(b) && "undefined" !== typeof c && "function" === typeof c.get && "function" === typeof c.set) {
        var e = c.get,
            f = c.set;
        Object.defineProperty(a, b, {
            configurable: !0,
            get: function() {
                return e.call(this)
            },
            set: function(a) {
                d = "" + a;
                f.call(this, a)
            }
        });
        Object.defineProperty(a, b, {
            enumerable: c.enumerable
        });
        return {
            getValue: function() {
                return d
            },
            setValue: function(a) {
                d = "" + a
            },
            stopTracking: function() {
                a._valueTracker =
                    null;
                delete a[b]
            }
        }
    }
}

function Va(a) {
    a._valueTracker || (a._valueTracker = Ua(a))
}

function Wa(a) {
    if (!a) return !1;
    var b = a._valueTracker;
    if (!b) return !0;
    var c = b.getValue();
    var d = "";
    a && (d = Ta(a) ? a.checked ? "true" : "false" : a.value);
    a = d;
    return a !== c ? (b.setValue(a), !0) : !1
}

function Xa(a) {
    a = a || ("undefined" !== typeof document ? document : void 0);
    if ("undefined" === typeof a) return null;
    try {
        return a.activeElement || a.body
    } catch (b) {
        return a.body
    }
}

function Ya(a, b) {
    var c = b.checked;
    return m({}, b, {
        defaultChecked: void 0,
        defaultValue: void 0,
        value: void 0,
        checked: null != c ? c : a._wrapperState.initialChecked
    })
}

function Za(a, b) {
    var c = null == b.defaultValue ? "" : b.defaultValue,
        d = null != b.checked ? b.checked : b.defaultChecked;
    c = Sa(null != b.value ? b.value : c);
    a._wrapperState = {
        initialChecked: d,
        initialValue: c,
        controlled: "checkbox" === b.type || "radio" === b.type ? null != b.checked : null != b.value
    }
}

function $a(a, b) {
    b = b.checked;
    null != b && qa(a, "checked", b, !1)
}

function ab(a, b) {
    $a(a, b);
    var c = Sa(b.value),
        d = b.type;
    if (null != c)
        if ("number" === d) {
            if (0 === c && "" === a.value || a.value != c) a.value = "" + c
        } else a.value !== "" + c && (a.value = "" + c);
    else if ("submit" === d || "reset" === d) {
        a.removeAttribute("value");
        return
    }
    b.hasOwnProperty("value") ? bb(a, b.type, c) : b.hasOwnProperty("defaultValue") && bb(a, b.type, Sa(b.defaultValue));
    null == b.checked && null != b.defaultChecked && (a.defaultChecked = !!b.defaultChecked)
}

function cb(a, b, c) {
    if (b.hasOwnProperty("value") || b.hasOwnProperty("defaultValue")) {
        var d = b.type;
        if (!("submit" !== d && "reset" !== d || void 0 !== b.value && null !== b.value)) return;
        b = "" + a._wrapperState.initialValue;
        c || b === a.value || (a.value = b);
        a.defaultValue = b
    }
    c = a.name;
    "" !== c && (a.name = "");
    a.defaultChecked = !!a._wrapperState.initialChecked;
    "" !== c && (a.name = c)
}

function bb(a, b, c) {
    if ("number" !== b || Xa(a.ownerDocument) !== a) null == c ? a.defaultValue = "" + a._wrapperState.initialValue : a.defaultValue !== "" + c && (a.defaultValue = "" + c)
}

function db(a) {
    var b = "";
    aa.Children.forEach(a, function(a) {
        null != a && (b += a)
    });
    return b
}

function eb(a, b) {
    a = m({
        children: void 0
    }, b);
    if (b = db(b.children)) a.children = b;
    return a
}

function fb(a, b, c, d) {
    a = a.options;
    if (b) {
        b = {};
        for (var e = 0; e < c.length; e++) b["$" + c[e]] = !0;
        for (c = 0; c < a.length; c++) e = b.hasOwnProperty("$" + a[c].value), a[c].selected !== e && (a[c].selected = e), e && d && (a[c].defaultSelected = !0)
    } else {
        c = "" + Sa(c);
        b = null;
        for (e = 0; e < a.length; e++) {
            if (a[e].value === c) {
                a[e].selected = !0;
                d && (a[e].defaultSelected = !0);
                return
            }
            null !== b || a[e].disabled || (b = a[e])
        }
        null !== b && (b.selected = !0)
    }
}

function gb(a, b) {
    if (null != b.dangerouslySetInnerHTML) throw Error(y(91));
    return m({}, b, {
        value: void 0,
        defaultValue: void 0,
        children: "" + a._wrapperState.initialValue
    })
}

function hb(a, b) {
    var c = b.value;
    if (null == c) {
        c = b.children;
        b = b.defaultValue;
        if (null != c) {
            if (null != b) throw Error(y(92));
            if (Array.isArray(c)) {
                if (!(1 >= c.length)) throw Error(y(93));
                c = c[0]
            }
            b = c
        }
        null == b && (b = "");
        c = b
    }
    a._wrapperState = {
        initialValue: Sa(c)
    }
}

function ib(a, b) {
    var c = Sa(b.value),
        d = Sa(b.defaultValue);
    null != c && (c = "" + c, c !== a.value && (a.value = c), null == b.defaultValue && a.defaultValue !== c && (a.defaultValue = c));
    null != d && (a.defaultValue = "" + d)
}

function jb(a) {
    var b = a.textContent;
    b === a._wrapperState.initialValue && "" !== b && null !== b && (a.value = b)
}
var kb = {
    html: "http://www.w3.org/1999/xhtml",
    mathml: "http://www.w3.org/1998/Math/MathML",
    svg: "http://www.w3.org/2000/svg"
};

function lb(a) {
    switch (a) {
        case "svg":
            return "http://www.w3.org/2000/svg";
        case "math":
            return "http://www.w3.org/1998/Math/MathML";
        default:
            return "http://www.w3.org/1999/xhtml"
    }
}

function mb(a, b) {
    return null == a || "http://www.w3.org/1999/xhtml" === a ? lb(b) : "http://www.w3.org/2000/svg" === a && "foreignObject" === b ? "http://www.w3.org/1999/xhtml" : a
}
var nb, ob = function(a) {
    return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function(b, c, d, e) {
        MSApp.execUnsafeLocalFunction(function() {
            return a(b, c, d, e)
        })
    } : a
}(function(a, b) {
    if (a.namespaceURI !== kb.svg || "innerHTML" in a) a.innerHTML = b;
    else {
        nb = nb || document.createElement("div");
        nb.innerHTML = "<svg>" + b.valueOf().toString() + "</svg>";
        for (b = nb.firstChild; a.firstChild;) a.removeChild(a.firstChild);
        for (; b.firstChild;) a.appendChild(b.firstChild)
    }
});

function pb(a, b) {
    if (b) {
        var c = a.firstChild;
        if (c && c === a.lastChild && 3 === c.nodeType) {
            c.nodeValue = b;
            return
        }
    }
    a.textContent = b
}
var qb = {
        animationIterationCount: !0,
        borderImageOutset: !0,
        borderImageSlice: !0,
        borderImageWidth: !0,
        boxFlex: !0,
        boxFlexGroup: !0,
        boxOrdinalGroup: !0,
        columnCount: !0,
        columns: !0,
        flex: !0,
        flexGrow: !0,
        flexPositive: !0,
        flexShrink: !0,
        flexNegative: !0,
        flexOrder: !0,
        gridArea: !0,
        gridRow: !0,
        gridRowEnd: !0,
        gridRowSpan: !0,
        gridRowStart: !0,
        gridColumn: !0,
        gridColumnEnd: !0,
        gridColumnSpan: !0,
        gridColumnStart: !0,
        fontWeight: !0,
        lineClamp: !0,
        lineHeight: !0,
        opacity: !0,
        order: !0,
        orphans: !0,
        tabSize: !0,
        widows: !0,
        zIndex: !0,
        zoom: !0,
        fillOpacity: !0,
        floodOpacity: !0,
        stopOpacity: !0,
        strokeDasharray: !0,
        strokeDashoffset: !0,
        strokeMiterlimit: !0,
        strokeOpacity: !0,
        strokeWidth: !0
    },
    rb = ["Webkit", "ms", "Moz", "O"];
Object.keys(qb).forEach(function(a) {
    rb.forEach(function(b) {
        b = b + a.charAt(0).toUpperCase() + a.substring(1);
        qb[b] = qb[a]
    })
});

function sb(a, b, c) {
    return null == b || "boolean" === typeof b || "" === b ? "" : c || "number" !== typeof b || 0 === b || qb.hasOwnProperty(a) && qb[a] ? ("" + b).trim() : b + "px"
}

function tb(a, b) {
    a = a.style;
    for (var c in b)
        if (b.hasOwnProperty(c)) {
            var d = 0 === c.indexOf("--"),
                e = sb(c, b[c], d);
            "float" === c && (c = "cssFloat");
            d ? a.setProperty(c, e) : a[c] = e
        }
}
var ub = m({
    menuitem: !0
}, {
    area: !0,
    base: !0,
    br: !0,
    col: !0,
    embed: !0,
    hr: !0,
    img: !0,
    input: !0,
    keygen: !0,
    link: !0,
    meta: !0,
    param: !0,
    source: !0,
    track: !0,
    wbr: !0
});

function vb(a, b) {
    if (b) {
        if (ub[a] && (null != b.children || null != b.dangerouslySetInnerHTML)) throw Error(y(137, a));
        if (null != b.dangerouslySetInnerHTML) {
            if (null != b.children) throw Error(y(60));
            if (!("object" === typeof b.dangerouslySetInnerHTML && "__html" in b.dangerouslySetInnerHTML)) throw Error(y(61));
        }
        if (null != b.style && "object" !== typeof b.style) throw Error(y(62));
    }
}

function wb(a, b) {
    if (-1 === a.indexOf("-")) return "string" === typeof b.is;
    switch (a) {
        case "annotation-xml":
        case "color-profile":
        case "font-face":
        case "font-face-src":
        case "font-face-uri":
        case "font-face-format":
        case "font-face-name":
        case "missing-glyph":
            return !1;
        default:
            return !0
    }
}

function xb(a) {
    a = a.target || a.srcElement || window;
    a.correspondingUseElement && (a = a.correspondingUseElement);
    return 3 === a.nodeType ? a.parentNode : a
}
var yb = null,
    zb = null,
    Ab = null;

function Bb(a) {
    if (a = Cb(a)) {
        if ("function" !== typeof yb) throw Error(y(280));
        var b = a.stateNode;
        b && (b = Db(b), yb(a.stateNode, a.type, b))
    }
}

function Eb(a) {
    zb ? Ab ? Ab.push(a) : Ab = [a] : zb = a
}

function Fb() {
    if (zb) {
        var a = zb,
            b = Ab;
        Ab = zb = null;
        Bb(a);
        if (b)
            for (a = 0; a < b.length; a++) Bb(b[a])
    }
}

function Gb(a, b) {
    return a(b)
}

function Hb(a, b, c, d, e) {
    return a(b, c, d, e)
}

function Ib() {}
var Jb = Gb,
    Kb = !1,
    Lb = !1;

function Mb() {
    if (null !== zb || null !== Ab) Ib(), Fb()
}

function Nb(a, b, c) {
    if (Lb) return a(b, c);
    Lb = !0;
    try {
        return Jb(a, b, c)
    } finally {
        Lb = !1, Mb()
    }
}

function Ob(a, b) {
    var c = a.stateNode;
    if (null === c) return null;
    var d = Db(c);
    if (null === d) return null;
    c = d[b];
    a: switch (b) {
        case "onClick":
        case "onClickCapture":
        case "onDoubleClick":
        case "onDoubleClickCapture":
        case "onMouseDown":
        case "onMouseDownCapture":
        case "onMouseMove":
        case "onMouseMoveCapture":
        case "onMouseUp":
        case "onMouseUpCapture":
        case "onMouseEnter":
            (d = !d.disabled) || (a = a.type, d = !("button" === a || "input" === a || "select" === a || "textarea" === a));
            a = !d;
            break a;
        default:
            a = !1
    }
    if (a) return null;
    if (c && "function" !==
        typeof c) throw Error(y(231, b, typeof c));
    return c
}
var Pb = !1;
if (fa) try {
    var Qb = {};
    Object.defineProperty(Qb, "passive", {get: function() {
            Pb = !0
        }
    });
    window.addEventListener("test", Qb, Qb);
    window.removeEventListener("test", Qb, Qb)
} catch (a) {
    Pb = !1
}

function Rb(a, b, c, d, e, f, g, h, k) {
    var l = Array.prototype.slice.call(arguments, 3);
    try {
        b.apply(c, l)
    } catch (n) {
        this.onError(n)
    }
}
var Sb = !1,
    Tb = null,
    Ub = !1,
    Vb = null,
    Wb = {
        onError: function(a) {
            Sb = !0;
            Tb = a
        }
    };

function Xb(a, b, c, d, e, f, g, h, k) {
    Sb = !1;
    Tb = null;
    Rb.apply(Wb, arguments)
}

function Yb(a, b, c, d, e, f, g, h, k) {
    Xb.apply(this, arguments);
    if (Sb) {
        if (Sb) {
            var l = Tb;
            Sb = !1;
            Tb = null
        } else throw Error(y(198));
        Ub || (Ub = !0, Vb = l)
    }
}

function Zb(a) {
    var b = a,
        c = a;
    if (a.alternate)
        for (; b.return;) b = b.return;
    else {
        a = b;
        do b = a, 0 !== (b.flags & 1026) && (c = b.return), a = b.return; while (a)
    }
    return 3 === b.tag ? c : null
}

function $b(a) {
    if (13 === a.tag) {
        var b = a.memoizedState;
        null === b && (a = a.alternate, null !== a && (b = a.memoizedState));
        if (null !== b) return b.dehydrated
    }
    return null
}

function ac(a) {
    if (Zb(a) !== a) throw Error(y(188));
}

function bc(a) {
    var b = a.alternate;
    if (!b) {
        b = Zb(a);
        if (null === b) throw Error(y(188));
        return b !== a ? null : a
    }
    for (var c = a, d = b;;) {
        var e = c.return;
        if (null === e) break;
        var f = e.alternate;
        if (null === f) {
            d = e.return;
            if (null !== d) {
                c = d;
                continue
            }
            break
        }
        if (e.child === f.child) {
            for (f = e.child; f;) {
                if (f === c) return ac(e), a;
                if (f === d) return ac(e), b;
                f = f.sibling
            }
            throw Error(y(188));
        }
        if (c.return !== d.return) c = e, d = f;
        else {
            for (var g = !1, h = e.child; h;) {
                if (h === c) {
                    g = !0;
                    c = e;
                    d = f;
                    break
                }
                if (h === d) {
                    g = !0;
                    d = e;
                    c = f;
                    break
                }
                h = h.sibling
            }
            if (!g) {
                for (h = f.child; h;) {
                    if (h ===
                        c) {
                        g = !0;
                        c = f;
                        d = e;
                        break
                    }
                    if (h === d) {
                        g = !0;
                        d = f;
                        c = e;
                        break
                    }
                    h = h.sibling
                }
                if (!g) throw Error(y(189));
            }
        }
        if (c.alternate !== d) throw Error(y(190));
    }
    if (3 !== c.tag) throw Error(y(188));
    return c.stateNode.current === c ? a : b
}

function cc(a) {
    a = bc(a);
    if (!a) return null;
    for (var b = a;;) {
        if (5 === b.tag || 6 === b.tag) return b;
        if (b.child) b.child.return = b, b = b.child;
        else {
            if (b === a) break;
            for (; !b.sibling;) {
                if (!b.return || b.return === a) return null;
                b = b.return
            }
            b.sibling.return = b.return;
            b = b.sibling
        }
    }
    return null
}

function dc(a, b) {
    for (var c = a.alternate; null !== b;) {
        if (b === a || b === c) return !0;
        b = b.return
    }
    return !1
}
var ec, fc, gc, hc, ic = !1,
    jc = [],
    kc = null,
    lc = null,
    mc = null,
    nc = new Map,
    oc = new Map,
    pc = [],
    qc = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" ");

function rc(a, b, c, d, e) {
    return {
        blockedOn: a,
        domEventName: b,
        eventSystemFlags: c | 16,
        nativeEvent: e,
        targetContainers: [d]
    }
}

function sc(a, b) {
    switch (a) {
        case "focusin":
        case "focusout":
            kc = null;
            break;
        case "dragenter":
        case "dragleave":
            lc = null;
            break;
        case "mouseover":
        case "mouseout":
            mc = null;
            break;
        case "pointerover":
        case "pointerout":
            nc.delete(b.pointerId);
            break;
        case "gotpointercapture":
        case "lostpointercapture":
            oc.delete(b.pointerId)
    }
}

function tc(a, b, c, d, e, f) {
    if (null === a || a.nativeEvent !== f) return a = rc(b, c, d, e, f), null !== b && (b = Cb(b), null !== b && fc(b)), a;
    a.eventSystemFlags |= d;
    b = a.targetContainers;
    null !== e && -1 === b.indexOf(e) && b.push(e);
    return a
}

function uc(a, b, c, d, e) {
    switch (b) {
        case "focusin":
            return kc = tc(kc, a, b, c, d, e), !0;
        case "dragenter":
            return lc = tc(lc, a, b, c, d, e), !0;
        case "mouseover":
            return mc = tc(mc, a, b, c, d, e), !0;
        case "pointerover":
            var f = e.pointerId;
            nc.set(f, tc(nc.get(f) || null, a, b, c, d, e));
            return !0;
        case "gotpointercapture":
            return f = e.pointerId, oc.set(f, tc(oc.get(f) || null, a, b, c, d, e)), !0
    }
    return !1
}

function vc(a) {
    var b = wc(a.target);
    if (null !== b) {
        var c = Zb(b);
        if (null !== c)
            if (b = c.tag, 13 === b) {
                if (b = $b(c), null !== b) {
                    a.blockedOn = b;
                    hc(a.lanePriority, function() {
                        r.unstable_runWithPriority(a.priority, function() {
                            gc(c)
                        })
                    });
                    return
                }
            } else if (3 === b && c.stateNode.hydrate) {
            a.blockedOn = 3 === c.tag ? c.stateNode.containerInfo : null;
            return
        }
    }
    a.blockedOn = null
}

function xc(a) {
    if (null !== a.blockedOn) return !1;
    for (var b = a.targetContainers; 0 < b.length;) {
        var c = yc(a.domEventName, a.eventSystemFlags, b[0], a.nativeEvent);
        if (null !== c) return b = Cb(c), null !== b && fc(b), a.blockedOn = c, !1;
        b.shift()
    }
    return !0
}

function zc(a, b, c) {
    xc(a) && c.delete(b)
}

function Ac() {
    for (ic = !1; 0 < jc.length;) {
        var a = jc[0];
        if (null !== a.blockedOn) {
            a = Cb(a.blockedOn);
            null !== a && ec(a);
            break
        }
        for (var b = a.targetContainers; 0 < b.length;) {
            var c = yc(a.domEventName, a.eventSystemFlags, b[0], a.nativeEvent);
            if (null !== c) {
                a.blockedOn = c;
                break
            }
            b.shift()
        }
        null === a.blockedOn && jc.shift()
    }
    null !== kc && xc(kc) && (kc = null);
    null !== lc && xc(lc) && (lc = null);
    null !== mc && xc(mc) && (mc = null);
    nc.forEach(zc);
    oc.forEach(zc)
}

function Bc(a, b) {
    a.blockedOn === b && (a.blockedOn = null, ic || (ic = !0, r.unstable_scheduleCallback(r.unstable_NormalPriority, Ac)))
}

function Cc(a) {
    function b(b) {
        return Bc(b, a)
    }
    if (0 < jc.length) {
        Bc(jc[0], a);
        for (var c = 1; c < jc.length; c++) {
            var d = jc[c];
            d.blockedOn === a && (d.blockedOn = null)
        }
    }
    null !== kc && Bc(kc, a);
    null !== lc && Bc(lc, a);
    null !== mc && Bc(mc, a);
    nc.forEach(b);
    oc.forEach(b);
    for (c = 0; c < pc.length; c++) d = pc[c], d.blockedOn === a && (d.blockedOn = null);
    for (; 0 < pc.length && (c = pc[0], null === c.blockedOn);) vc(c), null === c.blockedOn && pc.shift()
}

function Dc(a, b) {
    var c = {};
    c[a.toLowerCase()] = b.toLowerCase();
    c["Webkit" + a] = "webkit" + b;
    c["Moz" + a] = "moz" + b;
    return c
}
var Ec = {
        animationend: Dc("Animation", "AnimationEnd"),
        animationiteration: Dc("Animation", "AnimationIteration"),
        animationstart: Dc("Animation", "AnimationStart"),
        transitionend: Dc("Transition", "TransitionEnd")
    },
    Fc = {},
    Gc = {};
fa && (Gc = document.createElement("div").style, "AnimationEvent" in window || (delete Ec.animationend.animation, delete Ec.animationiteration.animation, delete Ec.animationstart.animation), "TransitionEvent" in window || delete Ec.transitionend.transition);

function Hc(a) {
    if (Fc[a]) return Fc[a];
    if (!Ec[a]) return a;
    var b = Ec[a],
        c;
    for (c in b)
        if (b.hasOwnProperty(c) && c in Gc) return Fc[a] = b[c];
    return a
}
var Ic = Hc("animationend"),
    Jc = Hc("animationiteration"),
    Kc = Hc("animationstart"),
    Lc = Hc("transitionend"),
    Mc = new Map,
    Nc = new Map,
    Oc = ["abort", "abort", Ic, "animationEnd", Jc, "animationIteration", Kc, "animationStart", "canplay", "canPlay", "canplaythrough", "canPlayThrough", "durationchange", "durationChange", "emptied", "emptied", "encrypted", "encrypted", "ended", "ended", "error", "error", "gotpointercapture", "gotPointerCapture", "load", "load", "loadeddata", "loadedData", "loadedmetadata", "loadedMetadata", "loadstart", "loadStart",
        "lostpointercapture", "lostPointerCapture", "playing", "playing", "progress", "progress", "seeking", "seeking", "stalled", "stalled", "suspend", "suspend", "timeupdate", "timeUpdate", Lc, "transitionEnd", "waiting", "waiting"
    ];

function Pc(a, b) {
    for (var c = 0; c < a.length; c += 2) {
        var d = a[c],
            e = a[c + 1];
        e = "on" + (e[0].toUpperCase() + e.slice(1));
        Nc.set(d, b);
        Mc.set(d, e);
        da(e, [d])
    }
}
var Qc = r.unstable_now;
Qc();
var F = 8;

function Rc(a) {
    if (0 !== (1 & a)) return F = 15, 1;
    if (0 !== (2 & a)) return F = 14, 2;
    if (0 !== (4 & a)) return F = 13, 4;
    var b = 24 & a;
    if (0 !== b) return F = 12, b;
    if (0 !== (a & 32)) return F = 11, 32;
    b = 192 & a;
    if (0 !== b) return F = 10, b;
    if (0 !== (a & 256)) return F = 9, 256;
    b = 3584 & a;
    if (0 !== b) return F = 8, b;
    if (0 !== (a & 4096)) return F = 7, 4096;
    b = 4186112 & a;
    if (0 !== b) return F = 6, b;
    b = 62914560 & a;
    if (0 !== b) return F = 5, b;
    if (a & 67108864) return F = 4, 67108864;
    if (0 !== (a & 134217728)) return F = 3, 134217728;
    b = 805306368 & a;
    if (0 !== b) return F = 2, b;
    if (0 !== (1073741824 & a)) return F = 1, 1073741824;
    F = 8;
    return a
}

function Sc(a) {
    switch (a) {
        case 99:
            return 15;
        case 98:
            return 10;
        case 97:
        case 96:
            return 8;
        case 95:
            return 2;
        default:
            return 0
    }
}

function Tc(a) {
    switch (a) {
        case 15:
        case 14:
            return 99;
        case 13:
        case 12:
        case 11:
        case 10:
            return 98;
        case 9:
        case 8:
        case 7:
        case 6:
        case 4:
        case 5:
            return 97;
        case 3:
        case 2:
        case 1:
            return 95;
        case 0:
            return 90;
        default:
            throw Error(y(358, a));
    }
}

function Uc(a, b) {
    var c = a.pendingLanes;
    if (0 === c) return F = 0;
    var d = 0,
        e = 0,
        f = a.expiredLanes,
        g = a.suspendedLanes,
        h = a.pingedLanes;
    if (0 !== f) d = f, e = F = 15;
    else if (f = c & 134217727, 0 !== f) {
        var k = f & ~g;
        0 !== k ? (d = Rc(k), e = F) : (h &= f, 0 !== h && (d = Rc(h), e = F))
    } else f = c & ~g, 0 !== f ? (d = Rc(f), e = F) : 0 !== h && (d = Rc(h), e = F);
    if (0 === d) return 0;
    d = 31 - Vc(d);
    d = c & ((0 > d ? 0 : 1 << d) << 1) - 1;
    if (0 !== b && b !== d && 0 === (b & g)) {
        Rc(b);
        if (e <= F) return b;
        F = e
    }
    b = a.entangledLanes;
    if (0 !== b)
        for (a = a.entanglements, b &= d; 0 < b;) c = 31 - Vc(b), e = 1 << c, d |= a[c], b &= ~e;
    return d
}

function Wc(a) {
    a = a.pendingLanes & -1073741825;
    return 0 !== a ? a : a & 1073741824 ? 1073741824 : 0
}

function Xc(a, b) {
    switch (a) {
        case 15:
            return 1;
        case 14:
            return 2;
        case 12:
            return a = Yc(24 & ~b), 0 === a ? Xc(10, b) : a;
        case 10:
            return a = Yc(192 & ~b), 0 === a ? Xc(8, b) : a;
        case 8:
            return a = Yc(3584 & ~b), 0 === a && (a = Yc(4186112 & ~b), 0 === a && (a = 512)), a;
        case 2:
            return b = Yc(805306368 & ~b), 0 === b && (b = 268435456), b
    }
    throw Error(y(358, a));
}

function Yc(a) {
    return a & -a
}

function Zc(a) {
    for (var b = [], c = 0; 31 > c; c++) b.push(a);
    return b
}

function $c(a, b, c) {
    a.pendingLanes |= b;
    var d = b - 1;
    a.suspendedLanes &= d;
    a.pingedLanes &= d;
    a = a.eventTimes;
    b = 31 - Vc(b);
    a[b] = c
}
var Vc = Math.clz32 ? Math.clz32 : ad,
    bd = Math.log,
    cd = Math.LN2;

function ad(a) {
    return 0 === a ? 32 : 31 - (bd(a) / cd | 0) | 0
}
var dd = r.unstable_UserBlockingPriority,
    ed = r.unstable_runWithPriority,
    fd = !0;

function gd(a, b, c, d) {
    Kb || Ib();
    var e = hd,
        f = Kb;
    Kb = !0;
    try {
        Hb(e, a, b, c, d)
    } finally {
        (Kb = f) || Mb()
    }
}

function id(a, b, c, d) {
    ed(dd, hd.bind(null, a, b, c, d))
}

function hd(a, b, c, d) {
    if (fd) {
        var e;
        if ((e = 0 === (b & 4)) && 0 < jc.length && -1 < qc.indexOf(a)) a = rc(null, a, b, c, d), jc.push(a);
        else {
            var f = yc(a, b, c, d);
            if (null === f) e && sc(a, d);
            else {
                if (e) {
                    if (-1 < qc.indexOf(a)) {
                        a = rc(f, a, b, c, d);
                        jc.push(a);
                        return
                    }
                    if (uc(f, a, b, c, d)) return;
                    sc(a, d)
                }
                jd(a, b, d, null, c)
            }
        }
    }
}

function yc(a, b, c, d) {
    var e = xb(d);
    e = wc(e);
    if (null !== e) {
        var f = Zb(e);
        if (null === f) e = null;
        else {
            var g = f.tag;
            if (13 === g) {
                e = $b(f);
                if (null !== e) return e;
                e = null
            } else if (3 === g) {
                if (f.stateNode.hydrate) return 3 === f.tag ? f.stateNode.containerInfo : null;
                e = null
            } else f !== e && (e = null)
        }
    }
    jd(a, b, d, e, c);
    return null
}
var kd = null,
    ld = null,
    md = null;

function nd() {
    if (md) return md;
    var a, b = ld,
        c = b.length,
        d, e = "value" in kd ? kd.value : kd.textContent,
        f = e.length;
    for (a = 0; a < c && b[a] === e[a]; a++);
    var g = c - a;
    for (d = 1; d <= g && b[c - d] === e[f - d]; d++);
    return md = e.slice(a, 1 < d ? 1 - d : void 0)
}

function od(a) {
    var b = a.keyCode;
    "charCode" in a ? (a = a.charCode, 0 === a && 13 === b && (a = 13)) : a = b;
    10 === a && (a = 13);
    return 32 <= a || 13 === a ? a : 0
}

function pd() {
    return !0
}

function qd() {
    return !1
}

function rd(a) {
    function b(b, d, e, f, g) {
        this._reactName = b;
        this._targetInst = e;
        this.type = d;
        this.nativeEvent = f;
        this.target = g;
        this.currentTarget = null;
        for (var c in a) a.hasOwnProperty(c) && (b = a[c], this[c] = b ? b(f) : f[c]);
        this.isDefaultPrevented = (null != f.defaultPrevented ? f.defaultPrevented : !1 === f.returnValue) ? pd : qd;
        this.isPropagationStopped = qd;
        return this
    }
    m(b.prototype, {
        preventDefault: function() {
            this.defaultPrevented = !0;
            var a = this.nativeEvent;
            a && (a.preventDefault ? a.preventDefault() : "unknown" !== typeof a.returnValue &&
                (a.returnValue = !1), this.isDefaultPrevented = pd)
        },
        stopPropagation: function() {
            var a = this.nativeEvent;
            a && (a.stopPropagation ? a.stopPropagation() : "unknown" !== typeof a.cancelBubble && (a.cancelBubble = !0), this.isPropagationStopped = pd)
        },
        persist: function() {},
        isPersistent: pd
    });
    return b
}
var sd = {
        eventPhase: 0,
        bubbles: 0,
        cancelable: 0,
        timeStamp: function(a) {
            return a.timeStamp || Date.now()
        },
        defaultPrevented: 0,
        isTrusted: 0
    },
    td = rd(sd),
    ud = m({}, sd, {
        view: 0,
        detail: 0
    }),
    vd = rd(ud),
    wd, xd, yd, Ad = m({}, ud, {
        screenX: 0,
        screenY: 0,
        clientX: 0,
        clientY: 0,
        pageX: 0,
        pageY: 0,
        ctrlKey: 0,
        shiftKey: 0,
        altKey: 0,
        metaKey: 0,
        getModifierState: zd,
        button: 0,
        buttons: 0,
        relatedTarget: function(a) {
            return void 0 === a.relatedTarget ? a.fromElement === a.srcElement ? a.toElement : a.fromElement : a.relatedTarget
        },
        movementX: function(a) {
            if ("movementX" in
                a) return a.movementX;
            a !== yd && (yd && "mousemove" === a.type ? (wd = a.screenX - yd.screenX, xd = a.screenY - yd.screenY) : xd = wd = 0, yd = a);
            return wd
        },
        movementY: function(a) {
            return "movementY" in a ? a.movementY : xd
        }
    }),
    Bd = rd(Ad),
    Cd = m({}, Ad, {
        dataTransfer: 0
    }),
    Dd = rd(Cd),
    Ed = m({}, ud, {
        relatedTarget: 0
    }),
    Fd = rd(Ed),
    Gd = m({}, sd, {
        animationName: 0,
        elapsedTime: 0,
        pseudoElement: 0
    }),
    Hd = rd(Gd),
    Id = m({}, sd, {
        clipboardData: function(a) {
            return "clipboardData" in a ? a.clipboardData : window.clipboardData
        }
    }),
    Jd = rd(Id),
    Kd = m({}, sd, {
        data: 0
    }),
    Ld = rd(Kd),
    Md = {
        Esc: "Escape",
        Spacebar: " ",
        Left: "ArrowLeft",
        Up: "ArrowUp",
        Right: "ArrowRight",
        Down: "ArrowDown",
        Del: "Delete",
        Win: "OS",
        Menu: "ContextMenu",
        Apps: "ContextMenu",
        Scroll: "ScrollLock",
        MozPrintableKey: "Unidentified"
    },
    Nd = {
        8: "Backspace",
        9: "Tab",
        12: "Clear",
        13: "Enter",
        16: "Shift",
        17: "Control",
        18: "Alt",
        19: "Pause",
        20: "CapsLock",
        27: "Escape",
        32: " ",
        33: "PageUp",
        34: "PageDown",
        35: "End",
        36: "Home",
        37: "ArrowLeft",
        38: "ArrowUp",
        39: "ArrowRight",
        40: "ArrowDown",
        45: "Insert",
        46: "Delete",
        112: "F1",
        113: "F2",
        114: "F3",
        115: "F4",
        116: "F5",
        117: "F6",
        118: "F7",
        119: "F8",
        120: "F9",
        121: "F10",
        122: "F11",
        123: "F12",
        144: "NumLock",
        145: "ScrollLock",
        224: "Meta"
    },
    Od = {
        Alt: "altKey",
        Control: "ctrlKey",
        Meta: "metaKey",
        Shift: "shiftKey"
    };

function Pd(a) {
    var b = this.nativeEvent;
    return b.getModifierState ? b.getModifierState(a) : (a = Od[a]) ? !!b[a] : !1
}

function zd() {
    return Pd
}
var Qd = m({}, ud, {
        key: function(a) {
            if (a.key) {
                var b = Md[a.key] || a.key;
                if ("Unidentified" !== b) return b
            }
            return "keypress" === a.type ? (a = od(a), 13 === a ? "Enter" : String.fromCharCode(a)) : "keydown" === a.type || "keyup" === a.type ? Nd[a.keyCode] || "Unidentified" : ""
        },
        code: 0,
        location: 0,
        ctrlKey: 0,
        shiftKey: 0,
        altKey: 0,
        metaKey: 0,
        repeat: 0,
        locale: 0,
        getModifierState: zd,
        charCode: function(a) {
            return "keypress" === a.type ? od(a) : 0
        },
        keyCode: function(a) {
            return "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0
        },
        which: function(a) {
            return "keypress" ===
                a.type ? od(a) : "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0
        }
    }),
    Rd = rd(Qd),
    Sd = m({}, Ad, {
        pointerId: 0,
        width: 0,
        height: 0,
        pressure: 0,
        tangentialPressure: 0,
        tiltX: 0,
        tiltY: 0,
        twist: 0,
        pointerType: 0,
        isPrimary: 0
    }),
    Td = rd(Sd),
    Ud = m({}, ud, {
        touches: 0,
        targetTouches: 0,
        changedTouches: 0,
        altKey: 0,
        metaKey: 0,
        ctrlKey: 0,
        shiftKey: 0,
        getModifierState: zd
    }),
    Vd = rd(Ud),
    Wd = m({}, sd, {
        propertyName: 0,
        elapsedTime: 0,
        pseudoElement: 0
    }),
    Xd = rd(Wd),
    Yd = m({}, Ad, {
        deltaX: function(a) {
            return "deltaX" in a ? a.deltaX : "wheelDeltaX" in a ? -a.wheelDeltaX : 0
        },
        deltaY: function(a) {
            return "deltaY" in a ? a.deltaY : "wheelDeltaY" in a ? -a.wheelDeltaY : "wheelDelta" in a ? -a.wheelDelta : 0
        },
        deltaZ: 0,
        deltaMode: 0
    }),
    Zd = rd(Yd),
    $d = [9, 13, 27, 32],
    ae = fa && "CompositionEvent" in window,
    be = null;
fa && "documentMode" in document && (be = document.documentMode);
var ce = fa && "TextEvent" in window && !be,
    de = fa && (!ae || be && 8 < be && 11 >= be),
    ee = String.fromCharCode(32),
    fe = !1;

function ge(a, b) {
    switch (a) {
        case "keyup":
            return -1 !== $d.indexOf(b.keyCode);
        case "keydown":
            return 229 !== b.keyCode;
        case "keypress":
        case "mousedown":
        case "focusout":
            return !0;
        default:
            return !1
    }
}

function he(a) {
    a = a.detail;
    return "object" === typeof a && "data" in a ? a.data : null
}
var ie = !1;

function je(a, b) {
    switch (a) {
        case "compositionend":
            return he(b);
        case "keypress":
            if (32 !== b.which) return null;
            fe = !0;
            return ee;
        case "textInput":
            return a = b.data, a === ee && fe ? null : a;
        default:
            return null
    }
}

function ke(a, b) {
    if (ie) return "compositionend" === a || !ae && ge(a, b) ? (a = nd(), md = ld = kd = null, ie = !1, a) : null;
    switch (a) {
        case "paste":
            return null;
        case "keypress":
            if (!(b.ctrlKey || b.altKey || b.metaKey) || b.ctrlKey && b.altKey) {
                if (b.char && 1 < b.char.length) return b.char;
                if (b.which) return String.fromCharCode(b.which)
            }
            return null;
        case "compositionend":
            return de && "ko" !== b.locale ? null : b.data;
        default:
            return null
    }
}
var le = {
    color: !0,
    date: !0,
    datetime: !0,
    "datetime-local": !0,
    email: !0,
    month: !0,
    number: !0,
    password: !0,
    range: !0,
    search: !0,
    tel: !0,
    text: !0,
    time: !0,
    url: !0,
    week: !0
};

function me(a) {
    var b = a && a.nodeName && a.nodeName.toLowerCase();
    return "input" === b ? !!le[a.type] : "textarea" === b ? !0 : !1
}

function ne(a, b, c, d) {
    Eb(d);
    b = oe(b, "onChange");
    0 < b.length && (c = new td("onChange", "change", null, c, d), a.push({
        event: c,
        listeners: b
    }))
}
var pe = null,
    qe = null;

function re(a) {
    se(a, 0)
}

function te(a) {
    var b = ue(a);
    if (Wa(b)) return a
}

function ve(a, b) {
    if ("change" === a) return b
}
var we = !1;
if (fa) {
    var xe;
    if (fa) {
        var ye = "oninput" in document;
        if (!ye) {
            var ze = document.createElement("div");
            ze.setAttribute("oninput", "return;");
            ye = "function" === typeof ze.oninput
        }
        xe = ye
    } else xe = !1;
    we = xe && (!document.documentMode || 9 < document.documentMode)
}

function Ae() {
    pe && (pe.detachEvent("onpropertychange", Be), qe = pe = null)
}

function Be(a) {
    if ("value" === a.propertyName && te(qe)) {
        var b = [];
        ne(b, qe, a, xb(a));
        a = re;
        if (Kb) a(b);
        else {
            Kb = !0;
            try {
                Gb(a, b)
            } finally {
                Kb = !1, Mb()
            }
        }
    }
}

function Ce(a, b, c) {
    "focusin" === a ? (Ae(), pe = b, qe = c, pe.attachEvent("onpropertychange", Be)) : "focusout" === a && Ae()
}

function De(a) {
    if ("selectionchange" === a || "keyup" === a || "keydown" === a) return te(qe)
}

function Ee(a, b) {
    if ("click" === a) return te(b)
}

function Fe(a, b) {
    if ("input" === a || "change" === a) return te(b)
}

function Ge(a, b) {
    return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b
}
var He = "function" === typeof Object.is ? Object.is : Ge,
    Ie = Object.prototype.hasOwnProperty;

function Je(a, b) {
    if (He(a, b)) return !0;
    if ("object" !== typeof a || null === a || "object" !== typeof b || null === b) return !1;
    var c = Object.keys(a),
        d = Object.keys(b);
    if (c.length !== d.length) return !1;
    for (d = 0; d < c.length; d++)
        if (!Ie.call(b, c[d]) || !He(a[c[d]], b[c[d]])) return !1;
    return !0
}

function Ke(a) {
    for (; a && a.firstChild;) a = a.firstChild;
    return a
}

function Le(a, b) {
    var c = Ke(a);
    a = 0;
    for (var d; c;) {
        if (3 === c.nodeType) {
            d = a + c.textContent.length;
            if (a <= b && d >= b) return {
                node: c,
                offset: b - a
            };
            a = d
        }
        a: {
            for (; c;) {
                if (c.nextSibling) {
                    c = c.nextSibling;
                    break a
                }
                c = c.parentNode
            }
            c = void 0
        }
        c = Ke(c)
    }
}

function Me(a, b) {
    return a && b ? a === b ? !0 : a && 3 === a.nodeType ? !1 : b && 3 === b.nodeType ? Me(a, b.parentNode) : "contains" in a ? a.contains(b) : a.compareDocumentPosition ? !!(a.compareDocumentPosition(b) & 16) : !1 : !1
}

function Ne() {
    for (var a = window, b = Xa(); b instanceof a.HTMLIFrameElement;) {
        try {
            var c = "string" === typeof b.contentWindow.location.href
        } catch (d) {
            c = !1
        }
        if (c) a = b.contentWindow;
        else break;
        b = Xa(a.document)
    }
    return b
}

function Oe(a) {
    var b = a && a.nodeName && a.nodeName.toLowerCase();
    return b && ("input" === b && ("text" === a.type || "search" === a.type || "tel" === a.type || "url" === a.type || "password" === a.type) || "textarea" === b || "true" === a.contentEditable)
}
var Pe = fa && "documentMode" in document && 11 >= document.documentMode,
    Qe = null,
    Re = null,
    Se = null,
    Te = !1;

function Ue(a, b, c) {
    var d = c.window === c ? c.document : 9 === c.nodeType ? c : c.ownerDocument;
    Te || null == Qe || Qe !== Xa(d) || (d = Qe, "selectionStart" in d && Oe(d) ? d = {
        start: d.selectionStart,
        end: d.selectionEnd
    } : (d = (d.ownerDocument && d.ownerDocument.defaultView || window).getSelection(), d = {
        anchorNode: d.anchorNode,
        anchorOffset: d.anchorOffset,
        focusNode: d.focusNode,
        focusOffset: d.focusOffset
    }), Se && Je(Se, d) || (Se = d, d = oe(Re, "onSelect"), 0 < d.length && (b = new td("onSelect", "select", null, b, c), a.push({
        event: b,
        listeners: d
    }), b.target = Qe)))
}
Pc("cancel cancel click click close close contextmenu contextMenu copy copy cut cut auxclick auxClick dblclick doubleClick dragend dragEnd dragstart dragStart drop drop focusin focus focusout blur input input invalid invalid keydown keyDown keypress keyPress keyup keyUp mousedown mouseDown mouseup mouseUp paste paste pause pause play play pointercancel pointerCancel pointerdown pointerDown pointerup pointerUp ratechange rateChange reset reset seeked seeked submit submit touchcancel touchCancel touchend touchEnd touchstart touchStart volumechange volumeChange".split(" "),
    0);
Pc("drag drag dragenter dragEnter dragexit dragExit dragleave dragLeave dragover dragOver mousemove mouseMove mouseout mouseOut mouseover mouseOver pointermove pointerMove pointerout pointerOut pointerover pointerOver scroll scroll toggle toggle touchmove touchMove wheel wheel".split(" "), 1);
Pc(Oc, 2);
for (var Ve = "change selectionchange textInput compositionstart compositionend compositionupdate".split(" "), We = 0; We < Ve.length; We++) Nc.set(Ve[We], 0);
ea("onMouseEnter", ["mouseout", "mouseover"]);
ea("onMouseLeave", ["mouseout", "mouseover"]);
ea("onPointerEnter", ["pointerout", "pointerover"]);
ea("onPointerLeave", ["pointerout", "pointerover"]);
da("onChange", "change click focusin focusout input keydown keyup selectionchange".split(" "));
da("onSelect", "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" "));
da("onBeforeInput", ["compositionend", "keypress", "textInput", "paste"]);
da("onCompositionEnd", "compositionend focusout keydown keypress keyup mousedown".split(" "));
da("onCompositionStart", "compositionstart focusout keydown keypress keyup mousedown".split(" "));
da("onCompositionUpdate", "compositionupdate focusout keydown keypress keyup mousedown".split(" "));
var Xe = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),
    Ye = new Set("cancel close invalid load scroll toggle".split(" ").concat(Xe));

function Ze(a, b, c) {
    var d = a.type || "unknown-event";
    a.currentTarget = c;
    Yb(d, b, void 0, a);
    a.currentTarget = null
}

function se(a, b) {
    b = 0 !== (b & 4);
    for (var c = 0; c < a.length; c++) {
        var d = a[c],
            e = d.event;
        d = d.listeners;
        a: {
            var f = void 0;
            if (b)
                for (var g = d.length - 1; 0 <= g; g--) {
                    var h = d[g],
                        k = h.instance,
                        l = h.currentTarget;
                    h = h.listener;
                    if (k !== f && e.isPropagationStopped()) break a;
                    Ze(e, h, l);
                    f = k
                } else
                    for (g = 0; g < d.length; g++) {
                        h = d[g];
                        k = h.instance;
                        l = h.currentTarget;
                        h = h.listener;
                        if (k !== f && e.isPropagationStopped()) break a;
                        Ze(e, h, l);
                        f = k
                    }
        }
    }
    if (Ub) throw a = Vb, Ub = !1, Vb = null, a;
}

function G(a, b) {
    var c = $e(b),
        d = a + "__bubble";
    c.has(d) || (af(b, a, 2, !1), c.add(d))
}
var bf = "_reactListening" + Math.random().toString(36).slice(2);

function cf(a) {
    a[bf] || (a[bf] = !0, ba.forEach(function(b) {
        Ye.has(b) || df(b, !1, a, null);
        df(b, !0, a, null)
    }))
}

function df(a, b, c, d) {
    var e = 4 < arguments.length && void 0 !== arguments[4] ? arguments[4] : 0,
        f = c;
    "selectionchange" === a && 9 !== c.nodeType && (f = c.ownerDocument);
    if (null !== d && !b && Ye.has(a)) {
        if ("scroll" !== a) return;
        e |= 2;
        f = d
    }
    var g = $e(f),
        h = a + "__" + (b ? "capture" : "bubble");
    g.has(h) || (b && (e |= 4), af(f, a, e, b), g.add(h))
}

function af(a, b, c, d) {
    var e = Nc.get(b);
    switch (void 0 === e ? 2 : e) {
        case 0:
            e = gd;
            break;
        case 1:
            e = id;
            break;
        default:
            e = hd
    }
    c = e.bind(null, b, c, a);
    e = void 0;
    !Pb || "touchstart" !== b && "touchmove" !== b && "wheel" !== b || (e = !0);
    d ? void 0 !== e ? a.addEventListener(b, c, {
        capture: !0,
        passive: e
    }) : a.addEventListener(b, c, !0) : void 0 !== e ? a.addEventListener(b, c, {
        passive: e
    }) : a.addEventListener(b, c, !1)
}

function jd(a, b, c, d, e) {
    var f = d;
    if (0 === (b & 1) && 0 === (b & 2) && null !== d) a: for (;;) {
        if (null === d) return;
        var g = d.tag;
        if (3 === g || 4 === g) {
            var h = d.stateNode.containerInfo;
            if (h === e || 8 === h.nodeType && h.parentNode === e) break;
            if (4 === g)
                for (g = d.return; null !== g;) {
                    var k = g.tag;
                    if (3 === k || 4 === k)
                        if (k = g.stateNode.containerInfo, k === e || 8 === k.nodeType && k.parentNode === e) return;
                    g = g.return
                }
            for (; null !== h;) {
                g = wc(h);
                if (null === g) return;
                k = g.tag;
                if (5 === k || 6 === k) {
                    d = f = g;
                    continue a
                }
                h = h.parentNode
            }
        }
        d = d.return
    }
    Nb(function() {
        var d = f,
            e = xb(c),
            g = [];
        a: {
            var h = Mc.get(a);
            if (void 0 !== h) {
                var k = td,
                    x = a;
                switch (a) {
                    case "keypress":
                        if (0 === od(c)) break a;
                    case "keydown":
                    case "keyup":
                        k = Rd;
                        break;
                    case "focusin":
                        x = "focus";
                        k = Fd;
                        break;
                    case "focusout":
                        x = "blur";
                        k = Fd;
                        break;
                    case "beforeblur":
                    case "afterblur":
                        k = Fd;
                        break;
                    case "click":
                        if (2 === c.button) break a;
                    case "auxclick":
                    case "dblclick":
                    case "mousedown":
                    case "mousemove":
                    case "mouseup":
                    case "mouseout":
                    case "mouseover":
                    case "contextmenu":
                        k = Bd;
                        break;
                    case "drag":
                    case "dragend":
                    case "dragenter":
                    case "dragexit":
                    case "dragleave":
                    case "dragover":
                    case "dragstart":
                    case "drop":
                        k =
                            Dd;
                        break;
                    case "touchcancel":
                    case "touchend":
                    case "touchmove":
                    case "touchstart":
                        k = Vd;
                        break;
                    case Ic:
                    case Jc:
                    case Kc:
                        k = Hd;
                        break;
                    case Lc:
                        k = Xd;
                        break;
                    case "scroll":
                        k = vd;
                        break;
                    case "wheel":
                        k = Zd;
                        break;
                    case "copy":
                    case "cut":
                    case "paste":
                        k = Jd;
                        break;
                    case "gotpointercapture":
                    case "lostpointercapture":
                    case "pointercancel":
                    case "pointerdown":
                    case "pointermove":
                    case "pointerout":
                    case "pointerover":
                    case "pointerup":
                        k = Td
                }
                var w = 0 !== (b & 4),
                    z = !w && "scroll" === a,
                    u = w ? null !== h ? h + "Capture" : null : h;
                w = [];
                for (var t = d, q; null !==
                    t;) {
                    q = t;
                    var v = q.stateNode;
                    5 === q.tag && null !== v && (q = v, null !== u && (v = Ob(t, u), null != v && w.push(ef(t, v, q))));
                    if (z) break;
                    t = t.return
                }
                0 < w.length && (h = new k(h, x, null, c, e), g.push({
                    event: h,
                    listeners: w
                }))
            }
        }
        if (0 === (b & 7)) {
            a: {
                h = "mouseover" === a || "pointerover" === a;
                k = "mouseout" === a || "pointerout" === a;
                if (h && 0 === (b & 16) && (x = c.relatedTarget || c.fromElement) && (wc(x) || x[ff])) break a;
                if (k || h) {
                    h = e.window === e ? e : (h = e.ownerDocument) ? h.defaultView || h.parentWindow : window;
                    if (k) {
                        if (x = c.relatedTarget || c.toElement, k = d, x = x ? wc(x) : null, null !==
                            x && (z = Zb(x), x !== z || 5 !== x.tag && 6 !== x.tag)) x = null
                    } else k = null, x = d;
                    if (k !== x) {
                        w = Bd;
                        v = "onMouseLeave";
                        u = "onMouseEnter";
                        t = "mouse";
                        if ("pointerout" === a || "pointerover" === a) w = Td, v = "onPointerLeave", u = "onPointerEnter", t = "pointer";
                        z = null == k ? h : ue(k);
                        q = null == x ? h : ue(x);
                        h = new w(v, t + "leave", k, c, e);
                        h.target = z;
                        h.relatedTarget = q;
                        v = null;
                        wc(e) === d && (w = new w(u, t + "enter", x, c, e), w.target = q, w.relatedTarget = z, v = w);
                        z = v;
                        if (k && x) b: {
                            w = k;
                            u = x;
                            t = 0;
                            for (q = w; q; q = gf(q)) t++;
                            q = 0;
                            for (v = u; v; v = gf(v)) q++;
                            for (; 0 < t - q;) w = gf(w), t--;
                            for (; 0 < q - t;) u =
                                gf(u), q--;
                            for (; t--;) {
                                if (w === u || null !== u && w === u.alternate) break b;
                                w = gf(w);
                                u = gf(u)
                            }
                            w = null
                        } else w = null;
                        null !== k && hf(g, h, k, w, !1);
                        null !== x && null !== z && hf(g, z, x, w, !0)
                    }
                }
            }
            a: {
                h = d ? ue(d) : window;
                k = h.nodeName && h.nodeName.toLowerCase();
                if ("select" === k || "input" === k && "file" === h.type) var J = ve;
                else if (me(h))
                    if (we) J = Fe;
                    else {
                        J = De;
                        var K = Ce
                    } else(k = h.nodeName) && "input" === k.toLowerCase() && ("checkbox" === h.type || "radio" === h.type) && (J = Ee);
                if (J && (J = J(a, d))) {
                    ne(g, J, c, e);
                    break a
                }
                K && K(a, h, d);
                "focusout" === a && (K = h._wrapperState) &&
                    K.controlled && "number" === h.type && bb(h, "number", h.value)
            }
            K = d ? ue(d) : window;
            switch (a) {
                case "focusin":
                    if (me(K) || "true" === K.contentEditable) Qe = K, Re = d, Se = null;
                    break;
                case "focusout":
                    Se = Re = Qe = null;
                    break;
                case "mousedown":
                    Te = !0;
                    break;
                case "contextmenu":
                case "mouseup":
                case "dragend":
                    Te = !1;
                    Ue(g, c, e);
                    break;
                case "selectionchange":
                    if (Pe) break;
                case "keydown":
                case "keyup":
                    Ue(g, c, e)
            }
            var Q;
            if (ae) b: {
                switch (a) {
                    case "compositionstart":
                        var L = "onCompositionStart";
                        break b;
                    case "compositionend":
                        L = "onCompositionEnd";
                        break b;
                    case "compositionupdate":
                        L = "onCompositionUpdate";
                        break b
                }
                L = void 0
            } else ie ? ge(a, c) && (L = "onCompositionEnd") : "keydown" === a && 229 === c.keyCode && (L = "onCompositionStart");L && (de && "ko" !== c.locale && (ie || "onCompositionStart" !== L ? "onCompositionEnd" === L && ie && (Q = nd()) : (kd = e, ld = "value" in kd ? kd.value : kd.textContent, ie = !0)), K = oe(d, L), 0 < K.length && (L = new Ld(L, a, null, c, e), g.push({
                event: L,
                listeners: K
            }), Q ? L.data = Q : (Q = he(c), null !== Q && (L.data = Q))));
            if (Q = ce ? je(a, c) : ke(a, c)) d = oe(d, "onBeforeInput"),
            0 < d.length && (e = new Ld("onBeforeInput",
                "beforeinput", null, c, e), g.push({
                event: e,
                listeners: d
            }), e.data = Q)
        }
        se(g, b)
    })
}

function ef(a, b, c) {
    return {
        instance: a,
        listener: b,
        currentTarget: c
    }
}

function oe(a, b) {
    for (var c = b + "Capture", d = []; null !== a;) {
        var e = a,
            f = e.stateNode;
        5 === e.tag && null !== f && (e = f, f = Ob(a, c), null != f && d.unshift(ef(a, f, e)), f = Ob(a, b), null != f && d.push(ef(a, f, e)));
        a = a.return
    }
    return d
}

function gf(a) {
    if (null === a) return null;
    do a = a.return; while (a && 5 !== a.tag);
    return a ? a : null
}

function hf(a, b, c, d, e) {
    for (var f = b._reactName, g = []; null !== c && c !== d;) {
        var h = c,
            k = h.alternate,
            l = h.stateNode;
        if (null !== k && k === d) break;
        5 === h.tag && null !== l && (h = l, e ? (k = Ob(c, f), null != k && g.unshift(ef(c, k, h))) : e || (k = Ob(c, f), null != k && g.push(ef(c, k, h))));
        c = c.return
    }
    0 !== g.length && a.push({
        event: b,
        listeners: g
    })
}

function jf() {}
var kf = null,
    lf = null;

function mf(a, b) {
    switch (a) {
        case "button":
        case "input":
        case "select":
        case "textarea":
            return !!b.autoFocus
    }
    return !1
}

function nf(a, b) {
    return "textarea" === a || "option" === a || "noscript" === a || "string" === typeof b.children || "number" === typeof b.children || "object" === typeof b.dangerouslySetInnerHTML && null !== b.dangerouslySetInnerHTML && null != b.dangerouslySetInnerHTML.__html
}
var of = "function" === typeof setTimeout ? setTimeout : void 0,
    pf = "function" === typeof clearTimeout ? clearTimeout : void 0;

function qf(a) {
    1 === a.nodeType ? a.textContent = "" : 9 === a.nodeType && (a = a.body, null != a && (a.textContent = ""))
}

function rf(a) {
    for (; null != a; a = a.nextSibling) {
        var b = a.nodeType;
        if (1 === b || 3 === b) break
    }
    return a
}

function sf(a) {
    a = a.previousSibling;
    for (var b = 0; a;) {
        if (8 === a.nodeType) {
            var c = a.data;
            if ("$" === c || "$!" === c || "$?" === c) {
                if (0 === b) return a;
                b--
            } else "/$" === c && b++
        }
        a = a.previousSibling
    }
    return null
}
var tf = 0;

function uf(a) {
    return {
        $$typeof: Ga,
        toString: a,
        valueOf: a
    }
}
var vf = Math.random().toString(36).slice(2),
    wf = "__reactFiber$" + vf,
    xf = "__reactProps$" + vf,
    ff = "__reactContainer$" + vf,
    yf = "__reactEvents$" + vf;

function wc(a) {
    var b = a[wf];
    if (b) return b;
    for (var c = a.parentNode; c;) {
        if (b = c[ff] || c[wf]) {
            c = b.alternate;
            if (null !== b.child || null !== c && null !== c.child)
                for (a = sf(a); null !== a;) {
                    if (c = a[wf]) return c;
                    a = sf(a)
                }
            return b
        }
        a = c;
        c = a.parentNode
    }
    return null
}

function Cb(a) {
    a = a[wf] || a[ff];
    return !a || 5 !== a.tag && 6 !== a.tag && 13 !== a.tag && 3 !== a.tag ? null : a
}

function ue(a) {
    if (5 === a.tag || 6 === a.tag) return a.stateNode;
    throw Error(y(33));
}

function Db(a) {
    return a[xf] || null
}

function $e(a) {
    var b = a[yf];
    void 0 === b && (b = a[yf] = new Set);
    return b
}
var zf = [],
    Af = -1;

function Bf(a) {
    return {
        current: a
    }
}

function H(a) {
    0 > Af || (a.current = zf[Af], zf[Af] = null, Af--)
}

function I(a, b) {
    Af++;
    zf[Af] = a.current;
    a.current = b
}
var Cf = {},
    M = Bf(Cf),
    N = Bf(!1),
    Df = Cf;

function Ef(a, b) {
    var c = a.type.contextTypes;
    if (!c) return Cf;
    var d = a.stateNode;
    if (d && d.__reactInternalMemoizedUnmaskedChildContext === b) return d.__reactInternalMemoizedMaskedChildContext;
    var e = {},
        f;
    for (f in c) e[f] = b[f];
    d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = b, a.__reactInternalMemoizedMaskedChildContext = e);
    return e
}

function Ff(a) {
    a = a.childContextTypes;
    return null !== a && void 0 !== a
}

function Gf() {
    H(N);
    H(M)
}

function Hf(a, b, c) {
    if (M.current !== Cf) throw Error(y(168));
    I(M, b);
    I(N, c)
}

function If(a, b, c) {
    var d = a.stateNode;
    a = b.childContextTypes;
    if ("function" !== typeof d.getChildContext) return c;
    d = d.getChildContext();
    for (var e in d)
        if (!(e in a)) throw Error(y(108, Ra(b) || "Unknown", e));
    return m({}, c, d)
}

function Jf(a) {
    a = (a = a.stateNode) && a.__reactInternalMemoizedMergedChildContext || Cf;
    Df = M.current;
    I(M, a);
    I(N, N.current);
    return !0
}

function Kf(a, b, c) {
    var d = a.stateNode;
    if (!d) throw Error(y(169));
    c ? (a = If(a, b, Df), d.__reactInternalMemoizedMergedChildContext = a, H(N), H(M), I(M, a)) : H(N);
    I(N, c)
}
var Lf = null,
    Mf = null,
    Nf = r.unstable_runWithPriority,
    Of = r.unstable_scheduleCallback,
    Pf = r.unstable_cancelCallback,
    Qf = r.unstable_shouldYield,
    Rf = r.unstable_requestPaint,
    Sf = r.unstable_now,
    Tf = r.unstable_getCurrentPriorityLevel,
    Uf = r.unstable_ImmediatePriority,
    Vf = r.unstable_UserBlockingPriority,
    Wf = r.unstable_NormalPriority,
    Xf = r.unstable_LowPriority,
    Yf = r.unstable_IdlePriority,
    Zf = {},
    $f = void 0 !== Rf ? Rf : function() {},
    ag = null,
    bg = null,
    cg = !1,
    dg = Sf(),
    O = 1E4 > dg ? Sf : function() {
        return Sf() - dg
    };

function eg() {
    switch (Tf()) {
        case Uf:
            return 99;
        case Vf:
            return 98;
        case Wf:
            return 97;
        case Xf:
            return 96;
        case Yf:
            return 95;
        default:
            throw Error(y(332));
    }
}

function fg(a) {
    switch (a) {
        case 99:
            return Uf;
        case 98:
            return Vf;
        case 97:
            return Wf;
        case 96:
            return Xf;
        case 95:
            return Yf;
        default:
            throw Error(y(332));
    }
}

function gg(a, b) {
    a = fg(a);
    return Nf(a, b)
}

function hg(a, b, c) {
    a = fg(a);
    return Of(a, b, c)
}

function ig() {
    if (null !== bg) {
        var a = bg;
        bg = null;
        Pf(a)
    }
    jg()
}

function jg() {
    if (!cg && null !== ag) {
        cg = !0;
        var a = 0;
        try {
            var b = ag;
            gg(99, function() {
                for (; a < b.length; a++) {
                    var c = b[a];
                    do c = c(!0); while (null !== c)
                }
            });
            ag = null
        } catch (c) {
            throw null !== ag && (ag = ag.slice(a + 1)), Of(Uf, ig), c;
        } finally {
            cg = !1
        }
    }
}
var kg = ra.ReactCurrentBatchConfig;

function lg(a, b) {
    if (a && a.defaultProps) {
        b = m({}, b);
        a = a.defaultProps;
        for (var c in a) void 0 === b[c] && (b[c] = a[c]);
        return b
    }
    return b
}
var mg = Bf(null),
    ng = null,
    og = null,
    pg = null;

function qg() {
    pg = og = ng = null
}

function rg(a) {
    var b = mg.current;
    H(mg);
    a.type._context._currentValue = b
}

function sg(a, b) {
    for (; null !== a;) {
        var c = a.alternate;
        if ((a.childLanes & b) === b)
            if (null === c || (c.childLanes & b) === b) break;
            else c.childLanes |= b;
        else a.childLanes |= b, null !== c && (c.childLanes |= b);
        a = a.return
    }
}

function tg(a, b) {
    ng = a;
    pg = og = null;
    a = a.dependencies;
    null !== a && null !== a.firstContext && (0 !== (a.lanes & b) && (ug = !0), a.firstContext = null)
}

function vg(a, b) {
    if (pg !== a && !1 !== b && 0 !== b) {
        if ("number" !== typeof b || 1073741823 === b) pg = a, b = 1073741823;
        b = {
            context: a,
            observedBits: b,
            next: null
        };
        if (null === og) {
            if (null === ng) throw Error(y(308));
            og = b;
            ng.dependencies = {
                lanes: 0,
                firstContext: b,
                responders: null
            }
        } else og = og.next = b
    }
    return a._currentValue
}
var wg = !1;

function xg(a) {
    a.updateQueue = {
        baseState: a.memoizedState,
        firstBaseUpdate: null,
        lastBaseUpdate: null,
        shared: {
            pending: null
        },
        effects: null
    }
}

function yg(a, b) {
    a = a.updateQueue;
    b.updateQueue === a && (b.updateQueue = {
        baseState: a.baseState,
        firstBaseUpdate: a.firstBaseUpdate,
        lastBaseUpdate: a.lastBaseUpdate,
        shared: a.shared,
        effects: a.effects
    })
}

function zg(a, b) {
    return {
        eventTime: a,
        lane: b,
        tag: 0,
        payload: null,
        callback: null,
        next: null
    }
}

function Ag(a, b) {
    a = a.updateQueue;
    if (null !== a) {
        a = a.shared;
        var c = a.pending;
        null === c ? b.next = b : (b.next = c.next, c.next = b);
        a.pending = b
    }
}

function Bg(a, b) {
    var c = a.updateQueue,
        d = a.alternate;
    if (null !== d && (d = d.updateQueue, c === d)) {
        var e = null,
            f = null;
        c = c.firstBaseUpdate;
        if (null !== c) {
            do {
                var g = {
                    eventTime: c.eventTime,
                    lane: c.lane,
                    tag: c.tag,
                    payload: c.payload,
                    callback: c.callback,
                    next: null
                };
                null === f ? e = f = g : f = f.next = g;
                c = c.next
            } while (null !== c);
            null === f ? e = f = b : f = f.next = b
        } else e = f = b;
        c = {
            baseState: d.baseState,
            firstBaseUpdate: e,
            lastBaseUpdate: f,
            shared: d.shared,
            effects: d.effects
        };
        a.updateQueue = c;
        return
    }
    a = c.lastBaseUpdate;
    null === a ? c.firstBaseUpdate = b : a.next =
        b;
    c.lastBaseUpdate = b
}

function Cg(a, b, c, d) {
    var e = a.updateQueue;
    wg = !1;
    var f = e.firstBaseUpdate,
        g = e.lastBaseUpdate,
        h = e.shared.pending;
    if (null !== h) {
        e.shared.pending = null;
        var k = h,
            l = k.next;
        k.next = null;
        null === g ? f = l : g.next = l;
        g = k;
        var n = a.alternate;
        if (null !== n) {
            n = n.updateQueue;
            var A = n.lastBaseUpdate;
            A !== g && (null === A ? n.firstBaseUpdate = l : A.next = l, n.lastBaseUpdate = k)
        }
    }
    if (null !== f) {
        A = e.baseState;
        g = 0;
        n = l = k = null;
        do {
            h = f.lane;
            var p = f.eventTime;
            if ((d & h) === h) {
                null !== n && (n = n.next = {
                    eventTime: p,
                    lane: 0,
                    tag: f.tag,
                    payload: f.payload,
                    callback: f.callback,
                    next: null
                });
                a: {
                    var C = a,
                        x = f;
                    h = b;
                    p = c;
                    switch (x.tag) {
                        case 1:
                            C = x.payload;
                            if ("function" === typeof C) {
                                A = C.call(p, A, h);
                                break a
                            }
                            A = C;
                            break a;
                        case 3:
                            C.flags = C.flags & -4097 | 64;
                        case 0:
                            C = x.payload;
                            h = "function" === typeof C ? C.call(p, A, h) : C;
                            if (null === h || void 0 === h) break a;
                            A = m({}, A, h);
                            break a;
                        case 2:
                            wg = !0
                    }
                }
                null !== f.callback && (a.flags |= 32, h = e.effects, null === h ? e.effects = [f] : h.push(f))
            } else p = {
                eventTime: p,
                lane: h,
                tag: f.tag,
                payload: f.payload,
                callback: f.callback,
                next: null
            }, null === n ? (l = n = p, k = A) : n = n.next = p, g |= h;
            f = f.next;
            if (null ===
                f)
                if (h = e.shared.pending, null === h) break;
                else f = h.next, h.next = null, e.lastBaseUpdate = h, e.shared.pending = null
        } while (1);
        null === n && (k = A);
        e.baseState = k;
        e.firstBaseUpdate = l;
        e.lastBaseUpdate = n;
        Dg |= g;
        a.lanes = g;
        a.memoizedState = A
    }
}

function Eg(a, b, c) {
    a = b.effects;
    b.effects = null;
    if (null !== a)
        for (b = 0; b < a.length; b++) {
            var d = a[b],
                e = d.callback;
            if (null !== e) {
                d.callback = null;
                d = c;
                if ("function" !== typeof e) throw Error(y(191, e));
                e.call(d)
            }
        }
}
var Fg = (new aa.Component).refs;

function Gg(a, b, c, d) {
    b = a.memoizedState;
    c = c(d, b);
    c = null === c || void 0 === c ? b : m({}, b, c);
    a.memoizedState = c;
    0 === a.lanes && (a.updateQueue.baseState = c)
}
var Kg = {
    isMounted: function(a) {
        return (a = a._reactInternals) ? Zb(a) === a : !1
    },
    enqueueSetState: function(a, b, c) {
        a = a._reactInternals;
        var d = Hg(),
            e = Ig(a),
            f = zg(d, e);
        f.payload = b;
        void 0 !== c && null !== c && (f.callback = c);
        Ag(a, f);
        Jg(a, e, d)
    },
    enqueueReplaceState: function(a, b, c) {
        a = a._reactInternals;
        var d = Hg(),
            e = Ig(a),
            f = zg(d, e);
        f.tag = 1;
        f.payload = b;
        void 0 !== c && null !== c && (f.callback = c);
        Ag(a, f);
        Jg(a, e, d)
    },
    enqueueForceUpdate: function(a, b) {
        a = a._reactInternals;
        var c = Hg(),
            d = Ig(a),
            e = zg(c, d);
        e.tag = 2;
        void 0 !== b && null !== b && (e.callback =
            b);
        Ag(a, e);
        Jg(a, d, c)
    }
};

function Lg(a, b, c, d, e, f, g) {
    a = a.stateNode;
    return "function" === typeof a.shouldComponentUpdate ? a.shouldComponentUpdate(d, f, g) : b.prototype && b.prototype.isPureReactComponent ? !Je(c, d) || !Je(e, f) : !0
}

function Mg(a, b, c) {
    var d = !1,
        e = Cf;
    var f = b.contextType;
    "object" === typeof f && null !== f ? f = vg(f) : (e = Ff(b) ? Df : M.current, d = b.contextTypes, f = (d = null !== d && void 0 !== d) ? Ef(a, e) : Cf);
    b = new b(c, f);
    a.memoizedState = null !== b.state && void 0 !== b.state ? b.state : null;
    b.updater = Kg;
    a.stateNode = b;
    b._reactInternals = a;
    d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = e, a.__reactInternalMemoizedMaskedChildContext = f);
    return b
}

function Ng(a, b, c, d) {
    a = b.state;
    "function" === typeof b.componentWillReceiveProps && b.componentWillReceiveProps(c, d);
    "function" === typeof b.UNSAFE_componentWillReceiveProps && b.UNSAFE_componentWillReceiveProps(c, d);
    b.state !== a && Kg.enqueueReplaceState(b, b.state, null)
}

function Og(a, b, c, d) {
    var e = a.stateNode;
    e.props = c;
    e.state = a.memoizedState;
    e.refs = Fg;
    xg(a);
    var f = b.contextType;
    "object" === typeof f && null !== f ? e.context = vg(f) : (f = Ff(b) ? Df : M.current, e.context = Ef(a, f));
    Cg(a, c, e, d);
    e.state = a.memoizedState;
    f = b.getDerivedStateFromProps;
    "function" === typeof f && (Gg(a, b, f, c), e.state = a.memoizedState);
    "function" === typeof b.getDerivedStateFromProps || "function" === typeof e.getSnapshotBeforeUpdate || "function" !== typeof e.UNSAFE_componentWillMount && "function" !== typeof e.componentWillMount ||
        (b = e.state, "function" === typeof e.componentWillMount && e.componentWillMount(), "function" === typeof e.UNSAFE_componentWillMount && e.UNSAFE_componentWillMount(), b !== e.state && Kg.enqueueReplaceState(e, e.state, null), Cg(a, c, e, d), e.state = a.memoizedState);
    "function" === typeof e.componentDidMount && (a.flags |= 4)
}
var Pg = Array.isArray;

function Qg(a, b, c) {
    a = c.ref;
    if (null !== a && "function" !== typeof a && "object" !== typeof a) {
        if (c._owner) {
            c = c._owner;
            if (c) {
                if (1 !== c.tag) throw Error(y(309));
                var d = c.stateNode
            }
            if (!d) throw Error(y(147, a));
            var e = "" + a;
            if (null !== b && null !== b.ref && "function" === typeof b.ref && b.ref._stringRef === e) return b.ref;
            b = function(a) {
                var b = d.refs;
                b === Fg && (b = d.refs = {});
                null === a ? delete b[e] : b[e] = a
            };
            b._stringRef = e;
            return b
        }
        if ("string" !== typeof a) throw Error(y(284));
        if (!c._owner) throw Error(y(290, a));
    }
    return a
}

function Rg(a, b) {
    if ("textarea" !== a.type) throw Error(y(31, "[object Object]" === Object.prototype.toString.call(b) ? "object with keys {" + Object.keys(b).join(", ") + "}" : b));
}

function Sg(a) {
    function b(b, c) {
        if (a) {
            var d = b.lastEffect;
            null !== d ? (d.nextEffect = c, b.lastEffect = c) : b.firstEffect = b.lastEffect = c;
            c.nextEffect = null;
            c.flags = 8
        }
    }

    function c(c, d) {
        if (!a) return null;
        for (; null !== d;) b(c, d), d = d.sibling;
        return null
    }

    function d(a, b) {
        for (a = new Map; null !== b;) null !== b.key ? a.set(b.key, b) : a.set(b.index, b), b = b.sibling;
        return a
    }

    function e(a, b) {
        a = Tg(a, b);
        a.index = 0;
        a.sibling = null;
        return a
    }

    function f(b, c, d) {
        b.index = d;
        if (!a) return c;
        d = b.alternate;
        if (null !== d) return d = d.index, d < c ? (b.flags = 2,
            c) : d;
        b.flags = 2;
        return c
    }

    function g(b) {
        a && null === b.alternate && (b.flags = 2);
        return b
    }

    function h(a, b, c, d) {
        if (null === b || 6 !== b.tag) return b = Ug(c, a.mode, d), b.return = a, b;
        b = e(b, c);
        b.return = a;
        return b
    }

    function k(a, b, c, d) {
        if (null !== b && b.elementType === c.type) return d = e(b, c.props), d.ref = Qg(a, b, c), d.return = a, d;
        d = Vg(c.type, c.key, c.props, null, a.mode, d);
        d.ref = Qg(a, b, c);
        d.return = a;
        return d
    }

    function l(a, b, c, d) {
        if (null === b || 4 !== b.tag || b.stateNode.containerInfo !== c.containerInfo || b.stateNode.implementation !== c.implementation) return b =
            Wg(c, a.mode, d), b.return = a, b;
        b = e(b, c.children || []);
        b.return = a;
        return b
    }

    function n(a, b, c, d, f) {
        if (null === b || 7 !== b.tag) return b = Xg(c, a.mode, d, f), b.return = a, b;
        b = e(b, c);
        b.return = a;
        return b
    }

    function A(a, b, c) {
        if ("string" === typeof b || "number" === typeof b) return b = Ug("" + b, a.mode, c), b.return = a, b;
        if ("object" === typeof b && null !== b) {
            switch (b.$$typeof) {
                case sa:
                    return c = Vg(b.type, b.key, b.props, null, a.mode, c), c.ref = Qg(a, null, b), c.return = a, c;
                case ta:
                    return b = Wg(b, a.mode, c), b.return = a, b
            }
            if (Pg(b) || La(b)) return b = Xg(b,
                a.mode, c, null), b.return = a, b;
            Rg(a, b)
        }
        return null
    }

    function p(a, b, c, d) {
        var e = null !== b ? b.key : null;
        if ("string" === typeof c || "number" === typeof c) return null !== e ? null : h(a, b, "" + c, d);
        if ("object" === typeof c && null !== c) {
            switch (c.$$typeof) {
                case sa:
                    return c.key === e ? c.type === ua ? n(a, b, c.props.children, d, e) : k(a, b, c, d) : null;
                case ta:
                    return c.key === e ? l(a, b, c, d) : null
            }
            if (Pg(c) || La(c)) return null !== e ? null : n(a, b, c, d, null);
            Rg(a, c)
        }
        return null
    }

    function C(a, b, c, d, e) {
        if ("string" === typeof d || "number" === typeof d) return a = a.get(c) ||
            null, h(b, a, "" + d, e);
        if ("object" === typeof d && null !== d) {
            switch (d.$$typeof) {
                case sa:
                    return a = a.get(null === d.key ? c : d.key) || null, d.type === ua ? n(b, a, d.props.children, e, d.key) : k(b, a, d, e);
                case ta:
                    return a = a.get(null === d.key ? c : d.key) || null, l(b, a, d, e)
            }
            if (Pg(d) || La(d)) return a = a.get(c) || null, n(b, a, d, e, null);
            Rg(b, d)
        }
        return null
    }

    function x(e, g, h, k) {
        for (var l = null, t = null, u = g, z = g = 0, q = null; null !== u && z < h.length; z++) {
            u.index > z ? (q = u, u = null) : q = u.sibling;
            var n = p(e, u, h[z], k);
            if (null === n) {
                null === u && (u = q);
                break
            }
            a && u && null ===
                n.alternate && b(e, u);
            g = f(n, g, z);
            null === t ? l = n : t.sibling = n;
            t = n;
            u = q
        }
        if (z === h.length) return c(e, u), l;
        if (null === u) {
            for (; z < h.length; z++) u = A(e, h[z], k), null !== u && (g = f(u, g, z), null === t ? l = u : t.sibling = u, t = u);
            return l
        }
        for (u = d(e, u); z < h.length; z++) q = C(u, e, z, h[z], k), null !== q && (a && null !== q.alternate && u.delete(null === q.key ? z : q.key), g = f(q, g, z), null === t ? l = q : t.sibling = q, t = q);
        a && u.forEach(function(a) {
            return b(e, a)
        });
        return l
    }

    function w(e, g, h, k) {
        var l = La(h);
        if ("function" !== typeof l) throw Error(y(150));
        h = l.call(h);
        if (null ==
            h) throw Error(y(151));
        for (var t = l = null, u = g, z = g = 0, q = null, n = h.next(); null !== u && !n.done; z++, n = h.next()) {
            u.index > z ? (q = u, u = null) : q = u.sibling;
            var w = p(e, u, n.value, k);
            if (null === w) {
                null === u && (u = q);
                break
            }
            a && u && null === w.alternate && b(e, u);
            g = f(w, g, z);
            null === t ? l = w : t.sibling = w;
            t = w;
            u = q
        }
        if (n.done) return c(e, u), l;
        if (null === u) {
            for (; !n.done; z++, n = h.next()) n = A(e, n.value, k), null !== n && (g = f(n, g, z), null === t ? l = n : t.sibling = n, t = n);
            return l
        }
        for (u = d(e, u); !n.done; z++, n = h.next()) n = C(u, e, z, n.value, k), null !== n && (a && null !== n.alternate &&
            u.delete(null === n.key ? z : n.key), g = f(n, g, z), null === t ? l = n : t.sibling = n, t = n);
        a && u.forEach(function(a) {
            return b(e, a)
        });
        return l
    }
    return function(a, d, f, h) {
        var k = "object" === typeof f && null !== f && f.type === ua && null === f.key;
        k && (f = f.props.children);
        var l = "object" === typeof f && null !== f;
        if (l) switch (f.$$typeof) {
            case sa:
                a: {
                    l = f.key;
                    for (k = d; null !== k;) {
                        if (k.key === l) {
                            switch (k.tag) {
                                case 7:
                                    if (f.type === ua) {
                                        c(a, k.sibling);
                                        d = e(k, f.props.children);
                                        d.return = a;
                                        a = d;
                                        break a
                                    }
                                    break;
                                default:
                                    if (k.elementType === f.type) {
                                        c(a, k.sibling);
                                        d = e(k, f.props);
                                        d.ref = Qg(a, k, f);
                                        d.return = a;
                                        a = d;
                                        break a
                                    }
                            }
                            c(a, k);
                            break
                        } else b(a, k);
                        k = k.sibling
                    }
                    f.type === ua ? (d = Xg(f.props.children, a.mode, h, f.key), d.return = a, a = d) : (h = Vg(f.type, f.key, f.props, null, a.mode, h), h.ref = Qg(a, d, f), h.return = a, a = h)
                }
                return g(a);
            case ta:
                a: {
                    for (k = f.key; null !== d;) {
                        if (d.key === k)
                            if (4 === d.tag && d.stateNode.containerInfo === f.containerInfo && d.stateNode.implementation === f.implementation) {
                                c(a, d.sibling);
                                d = e(d, f.children || []);
                                d.return = a;
                                a = d;
                                break a
                            } else {
                                c(a, d);
                                break
                            } else b(a, d);
                        d = d.sibling
                    }
                    d =
                        Wg(f, a.mode, h);
                    d.return = a;
                    a = d
                }
                return g(a)
        }
        if ("string" === typeof f || "number" === typeof f) return f = "" + f, null !== d && 6 === d.tag ? (c(a, d.sibling), d = e(d, f), d.return = a, a = d) : (c(a, d), d = Ug(f, a.mode, h), d.return = a, a = d), g(a);
        if (Pg(f)) return x(a, d, f, h);
        if (La(f)) return w(a, d, f, h);
        l && Rg(a, f);
        if ("undefined" === typeof f && !k) switch (a.tag) {
            case 1:
            case 22:
            case 0:
            case 11:
            case 15:
                throw Error(y(152, Ra(a.type) || "Component"));
        }
        return c(a, d)
    }
}
var Yg = Sg(!0),
    Zg = Sg(!1),
    $g = {},
    ah = Bf($g),
    bh = Bf($g),
    ch = Bf($g);

function dh(a) {
    if (a === $g) throw Error(y(174));
    return a
}

function eh(a, b) {
    I(ch, b);
    I(bh, a);
    I(ah, $g);
    a = b.nodeType;
    switch (a) {
        case 9:
        case 11:
            b = (b = b.documentElement) ? b.namespaceURI : mb(null, "");
            break;
        default:
            a = 8 === a ? b.parentNode : b, b = a.namespaceURI || null, a = a.tagName, b = mb(b, a)
    }
    H(ah);
    I(ah, b)
}

function fh() {
    H(ah);
    H(bh);
    H(ch)
}

function gh(a) {
    dh(ch.current);
    var b = dh(ah.current);
    var c = mb(b, a.type);
    b !== c && (I(bh, a), I(ah, c))
}

function hh(a) {
    bh.current === a && (H(ah), H(bh))
}
var P = Bf(0);

function ih(a) {
    for (var b = a; null !== b;) {
        if (13 === b.tag) {
            var c = b.memoizedState;
            if (null !== c && (c = c.dehydrated, null === c || "$?" === c.data || "$!" === c.data)) return b
        } else if (19 === b.tag && void 0 !== b.memoizedProps.revealOrder) {
            if (0 !== (b.flags & 64)) return b
        } else if (null !== b.child) {
            b.child.return = b;
            b = b.child;
            continue
        }
        if (b === a) break;
        for (; null === b.sibling;) {
            if (null === b.return || b.return === a) return null;
            b = b.return
        }
        b.sibling.return = b.return;
        b = b.sibling
    }
    return null
}
var jh = null,
    kh = null,
    lh = !1;

function mh(a, b) {
    var c = nh(5, null, null, 0);
    c.elementType = "DELETED";
    c.type = "DELETED";
    c.stateNode = b;
    c.return = a;
    c.flags = 8;
    null !== a.lastEffect ? (a.lastEffect.nextEffect = c, a.lastEffect = c) : a.firstEffect = a.lastEffect = c
}

function oh(a, b) {
    switch (a.tag) {
        case 5:
            var c = a.type;
            b = 1 !== b.nodeType || c.toLowerCase() !== b.nodeName.toLowerCase() ? null : b;
            return null !== b ? (a.stateNode = b, !0) : !1;
        case 6:
            return b = "" === a.pendingProps || 3 !== b.nodeType ? null : b, null !== b ? (a.stateNode = b, !0) : !1;
        case 13:
            return !1;
        default:
            return !1
    }
}

function ph(a) {
    if (lh) {
        var b = kh;
        if (b) {
            var c = b;
            if (!oh(a, b)) {
                b = rf(c.nextSibling);
                if (!b || !oh(a, b)) {
                    a.flags = a.flags & -1025 | 2;
                    lh = !1;
                    jh = a;
                    return
                }
                mh(jh, c)
            }
            jh = a;
            kh = rf(b.firstChild)
        } else a.flags = a.flags & -1025 | 2, lh = !1, jh = a
    }
}

function qh(a) {
    for (a = a.return; null !== a && 5 !== a.tag && 3 !== a.tag && 13 !== a.tag;) a = a.return;
    jh = a
}

function rh(a) {
    if (a !== jh) return !1;
    if (!lh) return qh(a), lh = !0, !1;
    var b = a.type;
    if (5 !== a.tag || "head" !== b && "body" !== b && !nf(b, a.memoizedProps))
        for (b = kh; b;) mh(a, b), b = rf(b.nextSibling);
    qh(a);
    if (13 === a.tag) {
        a = a.memoizedState;
        a = null !== a ? a.dehydrated : null;
        if (!a) throw Error(y(317));
        a: {
            a = a.nextSibling;
            for (b = 0; a;) {
                if (8 === a.nodeType) {
                    var c = a.data;
                    if ("/$" === c) {
                        if (0 === b) {
                            kh = rf(a.nextSibling);
                            break a
                        }
                        b--
                    } else "$" !== c && "$!" !== c && "$?" !== c || b++
                }
                a = a.nextSibling
            }
            kh = null
        }
    } else kh = jh ? rf(a.stateNode.nextSibling) : null;
    return !0
}

function sh() {
    kh = jh = null;
    lh = !1
}
var th = [];

function uh() {
    for (var a = 0; a < th.length; a++) th[a]._workInProgressVersionPrimary = null;
    th.length = 0
}
var vh = ra.ReactCurrentDispatcher,
    wh = ra.ReactCurrentBatchConfig,
    xh = 0,
    R = null,
    S = null,
    T = null,
    yh = !1,
    zh = !1;

function Ah() {
    throw Error(y(321));
}

function Bh(a, b) {
    if (null === b) return !1;
    for (var c = 0; c < b.length && c < a.length; c++)
        if (!He(a[c], b[c])) return !1;
    return !0
}

function Ch(a, b, c, d, e, f) {
    xh = f;
    R = b;
    b.memoizedState = null;
    b.updateQueue = null;
    b.lanes = 0;
    vh.current = null === a || null === a.memoizedState ? Dh : Eh;
    a = c(d, e);
    if (zh) {
        f = 0;
        do {
            zh = !1;
            if (!(25 > f)) throw Error(y(301));
            f += 1;
            T = S = null;
            b.updateQueue = null;
            vh.current = Fh;
            a = c(d, e)
        } while (zh)
    }
    vh.current = Gh;
    b = null !== S && null !== S.next;
    xh = 0;
    T = S = R = null;
    yh = !1;
    if (b) throw Error(y(300));
    return a
}

function Hh() {
    var a = {
        memoizedState: null,
        baseState: null,
        baseQueue: null,
        queue: null,
        next: null
    };
    null === T ? R.memoizedState = T = a : T = T.next = a;
    return T
}

function Ih() {
    if (null === S) {
        var a = R.alternate;
        a = null !== a ? a.memoizedState : null
    } else a = S.next;
    var b = null === T ? R.memoizedState : T.next;
    if (null !== b) T = b, S = a;
    else {
        if (null === a) throw Error(y(310));
        S = a;
        a = {
            memoizedState: S.memoizedState,
            baseState: S.baseState,
            baseQueue: S.baseQueue,
            queue: S.queue,
            next: null
        };
        null === T ? R.memoizedState = T = a : T = T.next = a
    }
    return T
}

function Jh(a, b) {
    return "function" === typeof b ? b(a) : b
}

function Kh(a) {
    var b = Ih(),
        c = b.queue;
    if (null === c) throw Error(y(311));
    c.lastRenderedReducer = a;
    var d = S,
        e = d.baseQueue,
        f = c.pending;
    if (null !== f) {
        if (null !== e) {
            var g = e.next;
            e.next = f.next;
            f.next = g
        }
        d.baseQueue = e = f;
        c.pending = null
    }
    if (null !== e) {
        e = e.next;
        d = d.baseState;
        var h = g = f = null,
            k = e;
        do {
            var l = k.lane;
            if ((xh & l) === l) null !== h && (h = h.next = {
                lane: 0,
                action: k.action,
                eagerReducer: k.eagerReducer,
                eagerState: k.eagerState,
                next: null
            }), d = k.eagerReducer === a ? k.eagerState : a(d, k.action);
            else {
                var n = {
                    lane: l,
                    action: k.action,
                    eagerReducer: k.eagerReducer,
                    eagerState: k.eagerState,
                    next: null
                };
                null === h ? (g = h = n, f = d) : h = h.next = n;
                R.lanes |= l;
                Dg |= l
            }
            k = k.next
        } while (null !== k && k !== e);
        null === h ? f = d : h.next = g;
        He(d, b.memoizedState) || (ug = !0);
        b.memoizedState = d;
        b.baseState = f;
        b.baseQueue = h;
        c.lastRenderedState = d
    }
    return [b.memoizedState, c.dispatch]
}

function Lh(a) {
    var b = Ih(),
        c = b.queue;
    if (null === c) throw Error(y(311));
    c.lastRenderedReducer = a;
    var d = c.dispatch,
        e = c.pending,
        f = b.memoizedState;
    if (null !== e) {
        c.pending = null;
        var g = e = e.next;
        do f = a(f, g.action), g = g.next; while (g !== e);
        He(f, b.memoizedState) || (ug = !0);
        b.memoizedState = f;
        null === b.baseQueue && (b.baseState = f);
        c.lastRenderedState = f
    }
    return [f, d]
}

function Mh(a, b, c) {
    var d = b._getVersion;
    d = d(b._source);
    var e = b._workInProgressVersionPrimary;
    if (null !== e) a = e === d;
    else if (a = a.mutableReadLanes, a = (xh & a) === a) b._workInProgressVersionPrimary = d, th.push(b);
    if (a) return c(b._source);
    th.push(b);
    throw Error(y(350));
}

function Nh(a, b, c, d) {
    var e = U;
    if (null === e) throw Error(y(349));
    var f = b._getVersion,
        g = f(b._source),
        h = vh.current,
        k = h.useState(function() {
            return Mh(e, b, c)
        }),
        l = k[1],
        n = k[0];
    k = T;
    var A = a.memoizedState,
        p = A.refs,
        C = p.getSnapshot,
        x = A.source;
    A = A.subscribe;
    var w = R;
    a.memoizedState = {
        refs: p,
        source: b,
        subscribe: d
    };
    h.useEffect(function() {
        p.getSnapshot = c;
        p.setSnapshot = l;
        var a = f(b._source);
        if (!He(g, a)) {
            a = c(b._source);
            He(n, a) || (l(a), a = Ig(w), e.mutableReadLanes |= a & e.pendingLanes);
            a = e.mutableReadLanes;
            e.entangledLanes |= a;
            for (var d =
                    e.entanglements, h = a; 0 < h;) {
                var k = 31 - Vc(h),
                    v = 1 << k;
                d[k] |= a;
                h &= ~v
            }
        }
    }, [c, b, d]);
    h.useEffect(function() {
        return d(b._source, function() {
            var a = p.getSnapshot,
                c = p.setSnapshot;
            try {
                c(a(b._source));
                var d = Ig(w);
                e.mutableReadLanes |= d & e.pendingLanes
            } catch (q) {
                c(function() {
                    throw q;
                })
            }
        })
    }, [b, d]);
    He(C, c) && He(x, b) && He(A, d) || (a = {
        pending: null,
        dispatch: null,
        lastRenderedReducer: Jh,
        lastRenderedState: n
    }, a.dispatch = l = Oh.bind(null, R, a), k.queue = a, k.baseQueue = null, n = Mh(e, b, c), k.memoizedState = k.baseState = n);
    return n
}

function Ph(a, b, c) {
    var d = Ih();
    return Nh(d, a, b, c)
}

function Qh(a) {
    var b = Hh();
    "function" === typeof a && (a = a());
    b.memoizedState = b.baseState = a;
    a = b.queue = {
        pending: null,
        dispatch: null,
        lastRenderedReducer: Jh,
        lastRenderedState: a
    };
    a = a.dispatch = Oh.bind(null, R, a);
    return [b.memoizedState, a]
}

function Rh(a, b, c, d) {
    a = {
        tag: a,
        create: b,
        destroy: c,
        deps: d,
        next: null
    };
    b = R.updateQueue;
    null === b ? (b = {
        lastEffect: null
    }, R.updateQueue = b, b.lastEffect = a.next = a) : (c = b.lastEffect, null === c ? b.lastEffect = a.next = a : (d = c.next, c.next = a, a.next = d, b.lastEffect = a));
    return a
}

function Sh(a) {
    var b = Hh();
    a = {
        current: a
    };
    return b.memoizedState = a
}

function Th() {
    return Ih().memoizedState
}

function Uh(a, b, c, d) {
    var e = Hh();
    R.flags |= a;
    e.memoizedState = Rh(1 | b, c, void 0, void 0 === d ? null : d)
}

function Vh(a, b, c, d) {
    var e = Ih();
    d = void 0 === d ? null : d;
    var f = void 0;
    if (null !== S) {
        var g = S.memoizedState;
        f = g.destroy;
        if (null !== d && Bh(d, g.deps)) {
            Rh(b, c, f, d);
            return
        }
    }
    R.flags |= a;
    e.memoizedState = Rh(1 | b, c, f, d)
}

function Wh(a, b) {
    return Uh(516, 4, a, b)
}

function Xh(a, b) {
    return Vh(516, 4, a, b)
}

function Yh(a, b) {
    return Vh(4, 2, a, b)
}

function Zh(a, b) {
    if ("function" === typeof b) return a = a(), b(a),
        function() {
            b(null)
        };
    if (null !== b && void 0 !== b) return a = a(), b.current = a,
        function() {
            b.current = null
        }
}

function $h(a, b, c) {
    c = null !== c && void 0 !== c ? c.concat([a]) : null;
    return Vh(4, 2, Zh.bind(null, b, a), c)
}

function ai() {}

function bi(a, b) {
    var c = Ih();
    b = void 0 === b ? null : b;
    var d = c.memoizedState;
    if (null !== d && null !== b && Bh(b, d[1])) return d[0];
    c.memoizedState = [a, b];
    return a
}

function ci(a, b) {
    var c = Ih();
    b = void 0 === b ? null : b;
    var d = c.memoizedState;
    if (null !== d && null !== b && Bh(b, d[1])) return d[0];
    a = a();
    c.memoizedState = [a, b];
    return a
}

function di(a, b) {
    var c = eg();
    gg(98 > c ? 98 : c, function() {
        a(!0)
    });
    gg(97 < c ? 97 : c, function() {
        var c = wh.transition;
        wh.transition = 1;
        try {
            a(!1), b()
        } finally {
            wh.transition = c
        }
    })
}

function Oh(a, b, c) {
    var d = Hg(),
        e = Ig(a),
        f = {
            lane: e,
            action: c,
            eagerReducer: null,
            eagerState: null,
            next: null
        },
        g = b.pending;
    null === g ? f.next = f : (f.next = g.next, g.next = f);
    b.pending = f;
    g = a.alternate;
    if (a === R || null !== g && g === R) zh = yh = !0;
    else {
        if (0 === a.lanes && (null === g || 0 === g.lanes) && (g = b.lastRenderedReducer, null !== g)) try {
            var h = b.lastRenderedState,
                k = g(h, c);
            f.eagerReducer = g;
            f.eagerState = k;
            if (He(k, h)) return
        } catch (l) {} finally {}
        Jg(a, e, d)
    }
}
var Gh = {
        readContext: vg,
        useCallback: Ah,
        useContext: Ah,
        useEffect: Ah,
        useImperativeHandle: Ah,
        useLayoutEffect: Ah,
        useMemo: Ah,
        useReducer: Ah,
        useRef: Ah,
        useState: Ah,
        useDebugValue: Ah,
        useDeferredValue: Ah,
        useTransition: Ah,
        useMutableSource: Ah,
        useOpaqueIdentifier: Ah,
        unstable_isNewReconciler: !1
    },
    Dh = {
        readContext: vg,
        useCallback: function(a, b) {
            Hh().memoizedState = [a, void 0 === b ? null : b];
            return a
        },
        useContext: vg,
        useEffect: Wh,
        useImperativeHandle: function(a, b, c) {
            c = null !== c && void 0 !== c ? c.concat([a]) : null;
            return Uh(4, 2, Zh.bind(null,
                b, a), c)
        },
        useLayoutEffect: function(a, b) {
            return Uh(4, 2, a, b)
        },
        useMemo: function(a, b) {
            var c = Hh();
            b = void 0 === b ? null : b;
            a = a();
            c.memoizedState = [a, b];
            return a
        },
        useReducer: function(a, b, c) {
            var d = Hh();
            b = void 0 !== c ? c(b) : b;
            d.memoizedState = d.baseState = b;
            a = d.queue = {
                pending: null,
                dispatch: null,
                lastRenderedReducer: a,
                lastRenderedState: b
            };
            a = a.dispatch = Oh.bind(null, R, a);
            return [d.memoizedState, a]
        },
        useRef: Sh,
        useState: Qh,
        useDebugValue: ai,
        useDeferredValue: function(a) {
            var b = Qh(a),
                c = b[0],
                d = b[1];
            Wh(function() {
                var b = wh.transition;
                wh.transition = 1;
                try {
                    d(a)
                } finally {
                    wh.transition = b
                }
            }, [a]);
            return c
        },
        useTransition: function() {
            var a = Qh(!1),
                b = a[0];
            a = di.bind(null, a[1]);
            Sh(a);
            return [a, b]
        },
        useMutableSource: function(a, b, c) {
            var d = Hh();
            d.memoizedState = {
                refs: {
                    getSnapshot: b,
                    setSnapshot: null
                },
                source: a,
                subscribe: c
            };
            return Nh(d, a, b, c)
        },
        useOpaqueIdentifier: function() {
            if (lh) {
                var a = !1,
                    b = uf(function() {
                        a || (a = !0, c("r:" + (tf++).toString(36)));
                        throw Error(y(355));
                    }),
                    c = Qh(b)[1];
                0 === (R.mode & 2) && (R.flags |= 516, Rh(5, function() {
                        c("r:" + (tf++).toString(36))
                    },
                    void 0, null));
                return b
            }
            b = "r:" + (tf++).toString(36);
            Qh(b);
            return b
        },
        unstable_isNewReconciler: !1
    },
    Eh = {
        readContext: vg,
        useCallback: bi,
        useContext: vg,
        useEffect: Xh,
        useImperativeHandle: $h,
        useLayoutEffect: Yh,
        useMemo: ci,
        useReducer: Kh,
        useRef: Th,
        useState: function() {
            return Kh(Jh)
        },
        useDebugValue: ai,
        useDeferredValue: function(a) {
            var b = Kh(Jh),
                c = b[0],
                d = b[1];
            Xh(function() {
                var b = wh.transition;
                wh.transition = 1;
                try {
                    d(a)
                } finally {
                    wh.transition = b
                }
            }, [a]);
            return c
        },
        useTransition: function() {
            var a = Kh(Jh)[0];
            return [Th().current,
                a
            ]
        },
        useMutableSource: Ph,
        useOpaqueIdentifier: function() {
            return Kh(Jh)[0]
        },
        unstable_isNewReconciler: !1
    },
    Fh = {
        readContext: vg,
        useCallback: bi,
        useContext: vg,
        useEffect: Xh,
        useImperativeHandle: $h,
        useLayoutEffect: Yh,
        useMemo: ci,
        useReducer: Lh,
        useRef: Th,
        useState: function() {
            return Lh(Jh)
        },
        useDebugValue: ai,
        useDeferredValue: function(a) {
            var b = Lh(Jh),
                c = b[0],
                d = b[1];
            Xh(function() {
                var b = wh.transition;
                wh.transition = 1;
                try {
                    d(a)
                } finally {
                    wh.transition = b
                }
            }, [a]);
            return c
        },
        useTransition: function() {
            var a = Lh(Jh)[0];
            return [Th().current,
                a
            ]
        },
        useMutableSource: Ph,
        useOpaqueIdentifier: function() {
            return Lh(Jh)[0]
        },
        unstable_isNewReconciler: !1
    },
    ei = ra.ReactCurrentOwner,
    ug = !1;

function fi(a, b, c, d) {
    b.child = null === a ? Zg(b, null, c, d) : Yg(b, a.child, c, d)
}

function gi(a, b, c, d, e) {
    c = c.render;
    var f = b.ref;
    tg(b, e);
    d = Ch(a, b, c, d, f, e);
    if (null !== a && !ug) return b.updateQueue = a.updateQueue, b.flags &= -517, a.lanes &= ~e, hi(a, b, e);
    b.flags |= 1;
    fi(a, b, d, e);
    return b.child
}

function ii(a, b, c, d, e, f) {
    if (null === a) {
        var g = c.type;
        if ("function" === typeof g && !ji(g) && void 0 === g.defaultProps && null === c.compare && void 0 === c.defaultProps) return b.tag = 15, b.type = g, ki(a, b, g, d, e, f);
        a = Vg(c.type, null, d, b, b.mode, f);
        a.ref = b.ref;
        a.return = b;
        return b.child = a
    }
    g = a.child;
    if (0 === (e & f) && (e = g.memoizedProps, c = c.compare, c = null !== c ? c : Je, c(e, d) && a.ref === b.ref)) return hi(a, b, f);
    b.flags |= 1;
    a = Tg(g, d);
    a.ref = b.ref;
    a.return = b;
    return b.child = a
}

function ki(a, b, c, d, e, f) {
    if (null !== a && Je(a.memoizedProps, d) && a.ref === b.ref)
        if (ug = !1, 0 !== (f & e)) 0 !== (a.flags & 16384) && (ug = !0);
        else return b.lanes = a.lanes, hi(a, b, f);
    return li(a, b, c, d, f)
}

function mi(a, b, c) {
    var d = b.pendingProps,
        e = d.children,
        f = null !== a ? a.memoizedState : null;
    if ("hidden" === d.mode || "unstable-defer-without-hiding" === d.mode)
        if (0 === (b.mode & 4)) b.memoizedState = {
            baseLanes: 0
        }, ni(b, c);
        else if (0 !== (c & 1073741824)) b.memoizedState = {
        baseLanes: 0
    }, ni(b, null !== f ? f.baseLanes : c);
    else return a = null !== f ? f.baseLanes | c : c, b.lanes = b.childLanes = 1073741824, b.memoizedState = {
        baseLanes: a
    }, ni(b, a), null;
    else null !== f ? (d = f.baseLanes | c, b.memoizedState = null) : d = c, ni(b, d);
    fi(a, b, e, c);
    return b.child
}

function oi(a, b) {
    var c = b.ref;
    if (null === a && null !== c || null !== a && a.ref !== c) b.flags |= 128
}

function li(a, b, c, d, e) {
    var f = Ff(c) ? Df : M.current;
    f = Ef(b, f);
    tg(b, e);
    c = Ch(a, b, c, d, f, e);
    if (null !== a && !ug) return b.updateQueue = a.updateQueue, b.flags &= -517, a.lanes &= ~e, hi(a, b, e);
    b.flags |= 1;
    fi(a, b, c, e);
    return b.child
}

function pi(a, b, c, d, e) {
    if (Ff(c)) {
        var f = !0;
        Jf(b)
    } else f = !1;
    tg(b, e);
    if (null === b.stateNode) null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2), Mg(b, c, d), Og(b, c, d, e), d = !0;
    else if (null === a) {
        var g = b.stateNode,
            h = b.memoizedProps;
        g.props = h;
        var k = g.context,
            l = c.contextType;
        "object" === typeof l && null !== l ? l = vg(l) : (l = Ff(c) ? Df : M.current, l = Ef(b, l));
        var n = c.getDerivedStateFromProps,
            A = "function" === typeof n || "function" === typeof g.getSnapshotBeforeUpdate;
        A || "function" !== typeof g.UNSAFE_componentWillReceiveProps &&
            "function" !== typeof g.componentWillReceiveProps || (h !== d || k !== l) && Ng(b, g, d, l);
        wg = !1;
        var p = b.memoizedState;
        g.state = p;
        Cg(b, d, g, e);
        k = b.memoizedState;
        h !== d || p !== k || N.current || wg ? ("function" === typeof n && (Gg(b, c, n, d), k = b.memoizedState), (h = wg || Lg(b, c, h, d, p, k, l)) ? (A || "function" !== typeof g.UNSAFE_componentWillMount && "function" !== typeof g.componentWillMount || ("function" === typeof g.componentWillMount && g.componentWillMount(), "function" === typeof g.UNSAFE_componentWillMount && g.UNSAFE_componentWillMount()), "function" ===
            typeof g.componentDidMount && (b.flags |= 4)) : ("function" === typeof g.componentDidMount && (b.flags |= 4), b.memoizedProps = d, b.memoizedState = k), g.props = d, g.state = k, g.context = l, d = h) : ("function" === typeof g.componentDidMount && (b.flags |= 4), d = !1)
    } else {
        g = b.stateNode;
        yg(a, b);
        h = b.memoizedProps;
        l = b.type === b.elementType ? h : lg(b.type, h);
        g.props = l;
        A = b.pendingProps;
        p = g.context;
        k = c.contextType;
        "object" === typeof k && null !== k ? k = vg(k) : (k = Ff(c) ? Df : M.current, k = Ef(b, k));
        var C = c.getDerivedStateFromProps;
        (n = "function" === typeof C ||
            "function" === typeof g.getSnapshotBeforeUpdate) || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== A || p !== k) && Ng(b, g, d, k);
        wg = !1;
        p = b.memoizedState;
        g.state = p;
        Cg(b, d, g, e);
        var x = b.memoizedState;
        h !== A || p !== x || N.current || wg ? ("function" === typeof C && (Gg(b, c, C, d), x = b.memoizedState), (l = wg || Lg(b, c, l, d, p, x, k)) ? (n || "function" !== typeof g.UNSAFE_componentWillUpdate && "function" !== typeof g.componentWillUpdate || ("function" === typeof g.componentWillUpdate && g.componentWillUpdate(d,
            x, k), "function" === typeof g.UNSAFE_componentWillUpdate && g.UNSAFE_componentWillUpdate(d, x, k)), "function" === typeof g.componentDidUpdate && (b.flags |= 4), "function" === typeof g.getSnapshotBeforeUpdate && (b.flags |= 256)) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && p === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && p === a.memoizedState || (b.flags |= 256), b.memoizedProps = d, b.memoizedState = x), g.props = d, g.state = x, g.context = k, d = l) : ("function" !== typeof g.componentDidUpdate ||
            h === a.memoizedProps && p === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && p === a.memoizedState || (b.flags |= 256), d = !1)
    }
    return qi(a, b, c, d, f, e)
}

function qi(a, b, c, d, e, f) {
    oi(a, b);
    var g = 0 !== (b.flags & 64);
    if (!d && !g) return e && Kf(b, c, !1), hi(a, b, f);
    d = b.stateNode;
    ei.current = b;
    var h = g && "function" !== typeof c.getDerivedStateFromError ? null : d.render();
    b.flags |= 1;
    null !== a && g ? (b.child = Yg(b, a.child, null, f), b.child = Yg(b, null, h, f)) : fi(a, b, h, f);
    b.memoizedState = d.state;
    e && Kf(b, c, !0);
    return b.child
}

function ri(a) {
    var b = a.stateNode;
    b.pendingContext ? Hf(a, b.pendingContext, b.pendingContext !== b.context) : b.context && Hf(a, b.context, !1);
    eh(a, b.containerInfo)
}
var si = {
    dehydrated: null,
    retryLane: 0
};

function ti(a, b, c) {
    var d = b.pendingProps,
        e = P.current,
        f = !1,
        g;
    (g = 0 !== (b.flags & 64)) || (g = null !== a && null === a.memoizedState ? !1 : 0 !== (e & 2));
    g ? (f = !0, b.flags &= -65) : null !== a && null === a.memoizedState || void 0 === d.fallback || !0 === d.unstable_avoidThisFallback || (e |= 1);
    I(P, e & 1);
    if (null === a) {
        void 0 !== d.fallback && ph(b);
        a = d.children;
        e = d.fallback;
        if (f) return a = ui(b, a, e, c), b.child.memoizedState = {
            baseLanes: c
        }, b.memoizedState = si, a;
        if ("number" === typeof d.unstable_expectedLoadTime) return a = ui(b, a, e, c), b.child.memoizedState = {
                baseLanes: c
            },
            b.memoizedState = si, b.lanes = 33554432, a;
        c = vi({
            mode: "visible",
            children: a
        }, b.mode, c, null);
        c.return = b;
        return b.child = c
    }
    if (null !== a.memoizedState) {
        if (f) return d = wi(a, b, d.children, d.fallback, c), f = b.child, e = a.child.memoizedState, f.memoizedState = null === e ? {
            baseLanes: c
        } : {
            baseLanes: e.baseLanes | c
        }, f.childLanes = a.childLanes & ~c, b.memoizedState = si, d;
        c = xi(a, b, d.children, c);
        b.memoizedState = null;
        return c
    }
    if (f) return d = wi(a, b, d.children, d.fallback, c), f = b.child, e = a.child.memoizedState, f.memoizedState = null === e ? {
        baseLanes: c
    } : {
        baseLanes: e.baseLanes | c
    }, f.childLanes = a.childLanes & ~c, b.memoizedState = si, d;
    c = xi(a, b, d.children, c);
    b.memoizedState = null;
    return c
}

function ui(a, b, c, d) {
    var e = a.mode,
        f = a.child;
    b = {
        mode: "hidden",
        children: b
    };
    0 === (e & 2) && null !== f ? (f.childLanes = 0, f.pendingProps = b) : f = vi(b, e, 0, null);
    c = Xg(c, e, d, null);
    f.return = a;
    c.return = a;
    f.sibling = c;
    a.child = f;
    return c
}

function xi(a, b, c, d) {
    var e = a.child;
    a = e.sibling;
    c = Tg(e, {
        mode: "visible",
        children: c
    });
    0 === (b.mode & 2) && (c.lanes = d);
    c.return = b;
    c.sibling = null;
    null !== a && (a.nextEffect = null, a.flags = 8, b.firstEffect = b.lastEffect = a);
    return b.child = c
}

function wi(a, b, c, d, e) {
    var f = b.mode,
        g = a.child;
    a = g.sibling;
    var h = {
        mode: "hidden",
        children: c
    };
    0 === (f & 2) && b.child !== g ? (c = b.child, c.childLanes = 0, c.pendingProps = h, g = c.lastEffect, null !== g ? (b.firstEffect = c.firstEffect, b.lastEffect = g, g.nextEffect = null) : b.firstEffect = b.lastEffect = null) : c = Tg(g, h);
    null !== a ? d = Tg(a, d) : (d = Xg(d, f, e, null), d.flags |= 2);
    d.return = b;
    c.return = b;
    c.sibling = d;
    b.child = c;
    return d
}

function yi(a, b) {
    a.lanes |= b;
    var c = a.alternate;
    null !== c && (c.lanes |= b);
    sg(a.return, b)
}

function zi(a, b, c, d, e, f) {
    var g = a.memoizedState;
    null === g ? a.memoizedState = {
        isBackwards: b,
        rendering: null,
        renderingStartTime: 0,
        last: d,
        tail: c,
        tailMode: e,
        lastEffect: f
    } : (g.isBackwards = b, g.rendering = null, g.renderingStartTime = 0, g.last = d, g.tail = c, g.tailMode = e, g.lastEffect = f)
}

function Ai(a, b, c) {
    var d = b.pendingProps,
        e = d.revealOrder,
        f = d.tail;
    fi(a, b, d.children, c);
    d = P.current;
    if (0 !== (d & 2)) d = d & 1 | 2, b.flags |= 64;
    else {
        if (null !== a && 0 !== (a.flags & 64)) a: for (a = b.child; null !== a;) {
            if (13 === a.tag) null !== a.memoizedState && yi(a, c);
            else if (19 === a.tag) yi(a, c);
            else if (null !== a.child) {
                a.child.return = a;
                a = a.child;
                continue
            }
            if (a === b) break a;
            for (; null === a.sibling;) {
                if (null === a.return || a.return === b) break a;
                a = a.return
            }
            a.sibling.return = a.return;
            a = a.sibling
        }
        d &= 1
    }
    I(P, d);
    if (0 === (b.mode & 2)) b.memoizedState =
        null;
    else switch (e) {
        case "forwards":
            c = b.child;
            for (e = null; null !== c;) a = c.alternate, null !== a && null === ih(a) && (e = c), c = c.sibling;
            c = e;
            null === c ? (e = b.child, b.child = null) : (e = c.sibling, c.sibling = null);
            zi(b, !1, e, c, f, b.lastEffect);
            break;
        case "backwards":
            c = null;
            e = b.child;
            for (b.child = null; null !== e;) {
                a = e.alternate;
                if (null !== a && null === ih(a)) {
                    b.child = e;
                    break
                }
                a = e.sibling;
                e.sibling = c;
                c = e;
                e = a
            }
            zi(b, !0, c, null, f, b.lastEffect);
            break;
        case "together":
            zi(b, !1, null, null, void 0, b.lastEffect);
            break;
        default:
            b.memoizedState = null
    }
    return b.child
}

function hi(a, b, c) {
    null !== a && (b.dependencies = a.dependencies);
    Dg |= b.lanes;
    if (0 !== (c & b.childLanes)) {
        if (null !== a && b.child !== a.child) throw Error(y(153));
        if (null !== b.child) {
            a = b.child;
            c = Tg(a, a.pendingProps);
            b.child = c;
            for (c.return = b; null !== a.sibling;) a = a.sibling, c = c.sibling = Tg(a, a.pendingProps), c.return = b;
            c.sibling = null
        }
        return b.child
    }
    return null
}
var Bi, Ci, Di, Ei;
Bi = function(a, b) {
    for (var c = b.child; null !== c;) {
        if (5 === c.tag || 6 === c.tag) a.appendChild(c.stateNode);
        else if (4 !== c.tag && null !== c.child) {
            c.child.return = c;
            c = c.child;
            continue
        }
        if (c === b) break;
        for (; null === c.sibling;) {
            if (null === c.return || c.return === b) return;
            c = c.return
        }
        c.sibling.return = c.return;
        c = c.sibling
    }
};
Ci = function() {};
Di = function(a, b, c, d) {
    var e = a.memoizedProps;
    if (e !== d) {
        a = b.stateNode;
        dh(ah.current);
        var f = null;
        switch (c) {
            case "input":
                e = Ya(a, e);
                d = Ya(a, d);
                f = [];
                break;
            case "option":
                e = eb(a, e);
                d = eb(a, d);
                f = [];
                break;
            case "select":
                e = m({}, e, {
                    value: void 0
                });
                d = m({}, d, {
                    value: void 0
                });
                f = [];
                break;
            case "textarea":
                e = gb(a, e);
                d = gb(a, d);
                f = [];
                break;
            default:
                "function" !== typeof e.onClick && "function" === typeof d.onClick && (a.onclick = jf)
        }
        vb(c, d);
        var g;
        c = null;
        for (l in e)
            if (!d.hasOwnProperty(l) && e.hasOwnProperty(l) && null != e[l])
                if ("style" ===
                    l) {
                    var h = e[l];
                    for (g in h) h.hasOwnProperty(g) && (c || (c = {}), c[g] = "")
                } else "dangerouslySetInnerHTML" !== l && "children" !== l && "suppressContentEditableWarning" !== l && "suppressHydrationWarning" !== l && "autoFocus" !== l && (ca.hasOwnProperty(l) ? f || (f = []) : (f = f || []).push(l, null));
        for (l in d) {
            var k = d[l];
            h = null != e ? e[l] : void 0;
            if (d.hasOwnProperty(l) && k !== h && (null != k || null != h))
                if ("style" === l)
                    if (h) {
                        for (g in h) !h.hasOwnProperty(g) || k && k.hasOwnProperty(g) || (c || (c = {}), c[g] = "");
                        for (g in k) k.hasOwnProperty(g) && h[g] !== k[g] && (c ||
                            (c = {}), c[g] = k[g])
                    } else c || (f || (f = []), f.push(l, c)), c = k;
            else "dangerouslySetInnerHTML" === l ? (k = k ? k.__html : void 0, h = h ? h.__html : void 0, null != k && h !== k && (f = f || []).push(l, k)) : "children" === l ? "string" !== typeof k && "number" !== typeof k || (f = f || []).push(l, "" + k) : "suppressContentEditableWarning" !== l && "suppressHydrationWarning" !== l && (ca.hasOwnProperty(l) ? (null != k && "onScroll" === l && G("scroll", a), f || h === k || (f = [])) : "object" === typeof k && null !== k && k.$$typeof === Ga ? k.toString() : (f = f || []).push(l, k))
        }
        c && (f = f || []).push("style",
            c);
        var l = f;
        if (b.updateQueue = l) b.flags |= 4
    }
};
Ei = function(a, b, c, d) {
    c !== d && (b.flags |= 4)
};

function Fi(a, b) {
    if (!lh) switch (a.tailMode) {
        case "hidden":
            b = a.tail;
            for (var c = null; null !== b;) null !== b.alternate && (c = b), b = b.sibling;
            null === c ? a.tail = null : c.sibling = null;
            break;
        case "collapsed":
            c = a.tail;
            for (var d = null; null !== c;) null !== c.alternate && (d = c), c = c.sibling;
            null === d ? b || null === a.tail ? a.tail = null : a.tail.sibling = null : d.sibling = null
    }
}

function Gi(a, b, c) {
    var d = b.pendingProps;
    switch (b.tag) {
        case 2:
        case 16:
        case 15:
        case 0:
        case 11:
        case 7:
        case 8:
        case 12:
        case 9:
        case 14:
            return null;
        case 1:
            return Ff(b.type) && Gf(), null;
        case 3:
            fh();
            H(N);
            H(M);
            uh();
            d = b.stateNode;
            d.pendingContext && (d.context = d.pendingContext, d.pendingContext = null);
            if (null === a || null === a.child) rh(b) ? b.flags |= 4 : d.hydrate || (b.flags |= 256);
            Ci(b);
            return null;
        case 5:
            hh(b);
            var e = dh(ch.current);
            c = b.type;
            if (null !== a && null != b.stateNode) Di(a, b, c, d, e), a.ref !== b.ref && (b.flags |= 128);
            else {
                if (!d) {
                    if (null ===
                        b.stateNode) throw Error(y(166));
                    return null
                }
                a = dh(ah.current);
                if (rh(b)) {
                    d = b.stateNode;
                    c = b.type;
                    var f = b.memoizedProps;
                    d[wf] = b;
                    d[xf] = f;
                    switch (c) {
                        case "dialog":
                            G("cancel", d);
                            G("close", d);
                            break;
                        case "iframe":
                        case "object":
                        case "embed":
                            G("load", d);
                            break;
                        case "video":
                        case "audio":
                            for (a = 0; a < Xe.length; a++) G(Xe[a], d);
                            break;
                        case "source":
                            G("error", d);
                            break;
                        case "img":
                        case "image":
                        case "link":
                            G("error", d);
                            G("load", d);
                            break;
                        case "details":
                            G("toggle", d);
                            break;
                        case "input":
                            Za(d, f);
                            G("invalid", d);
                            break;
                        case "select":
                            d._wrapperState = {
                                wasMultiple: !!f.multiple
                            };
                            G("invalid", d);
                            break;
                        case "textarea":
                            hb(d, f), G("invalid", d)
                    }
                    vb(c, f);
                    a = null;
                    for (var g in f) f.hasOwnProperty(g) && (e = f[g], "children" === g ? "string" === typeof e ? d.textContent !== e && (a = ["children", e]) : "number" === typeof e && d.textContent !== "" + e && (a = ["children", "" + e]) : ca.hasOwnProperty(g) && null != e && "onScroll" === g && G("scroll", d));
                    switch (c) {
                        case "input":
                            Va(d);
                            cb(d, f, !0);
                            break;
                        case "textarea":
                            Va(d);
                            jb(d);
                            break;
                        case "select":
                        case "option":
                            break;
                        default:
                            "function" === typeof f.onClick && (d.onclick =
                                jf)
                    }
                    d = a;
                    b.updateQueue = d;
                    null !== d && (b.flags |= 4)
                } else {
                    g = 9 === e.nodeType ? e : e.ownerDocument;
                    a === kb.html && (a = lb(c));
                    a === kb.html ? "script" === c ? (a = g.createElement("div"), a.innerHTML = "<script>\x3c/script>", a = a.removeChild(a.firstChild)) : "string" === typeof d.is ? a = g.createElement(c, {
                        is: d.is
                    }) : (a = g.createElement(c), "select" === c && (g = a, d.multiple ? g.multiple = !0 : d.size && (g.size = d.size))) : a = g.createElementNS(a, c);
                    a[wf] = b;
                    a[xf] = d;
                    Bi(a, b, !1, !1);
                    b.stateNode = a;
                    g = wb(c, d);
                    switch (c) {
                        case "dialog":
                            G("cancel", a);
                            G("close", a);
                            e = d;
                            break;
                        case "iframe":
                        case "object":
                        case "embed":
                            G("load", a);
                            e = d;
                            break;
                        case "video":
                        case "audio":
                            for (e = 0; e < Xe.length; e++) G(Xe[e], a);
                            e = d;
                            break;
                        case "source":
                            G("error", a);
                            e = d;
                            break;
                        case "img":
                        case "image":
                        case "link":
                            G("error", a);
                            G("load", a);
                            e = d;
                            break;
                        case "details":
                            G("toggle", a);
                            e = d;
                            break;
                        case "input":
                            Za(a, d);
                            e = Ya(a, d);
                            G("invalid", a);
                            break;
                        case "option":
                            e = eb(a, d);
                            break;
                        case "select":
                            a._wrapperState = {
                                wasMultiple: !!d.multiple
                            };
                            e = m({}, d, {
                                value: void 0
                            });
                            G("invalid", a);
                            break;
                        case "textarea":
                            hb(a, d);
                            e =
                                gb(a, d);
                            G("invalid", a);
                            break;
                        default:
                            e = d
                    }
                    vb(c, e);
                    var h = e;
                    for (f in h)
                        if (h.hasOwnProperty(f)) {
                            var k = h[f];
                            "style" === f ? tb(a, k) : "dangerouslySetInnerHTML" === f ? (k = k ? k.__html : void 0, null != k && ob(a, k)) : "children" === f ? "string" === typeof k ? ("textarea" !== c || "" !== k) && pb(a, k) : "number" === typeof k && pb(a, "" + k) : "suppressContentEditableWarning" !== f && "suppressHydrationWarning" !== f && "autoFocus" !== f && (ca.hasOwnProperty(f) ? null != k && "onScroll" === f && G("scroll", a) : null != k && qa(a, f, k, g))
                        }
                    switch (c) {
                        case "input":
                            Va(a);
                            cb(a, d, !1);
                            break;
                        case "textarea":
                            Va(a);
                            jb(a);
                            break;
                        case "option":
                            null != d.value && a.setAttribute("value", "" + Sa(d.value));
                            break;
                        case "select":
                            a.multiple = !!d.multiple;
                            f = d.value;
                            null != f ? fb(a, !!d.multiple, f, !1) : null != d.defaultValue && fb(a, !!d.multiple, d.defaultValue, !0);
                            break;
                        default:
                            "function" === typeof e.onClick && (a.onclick = jf)
                    }
                    mf(c, d) && (b.flags |= 4)
                }
                null !== b.ref && (b.flags |= 128)
            }
            return null;
        case 6:
            if (a && null != b.stateNode) Ei(a, b, a.memoizedProps, d);
            else {
                if ("string" !== typeof d && null === b.stateNode) throw Error(y(166));
                c = dh(ch.current);
                dh(ah.current);
                rh(b) ? (d = b.stateNode, c = b.memoizedProps, d[wf] = b, d.nodeValue !== c && (b.flags |= 4)) : (d = (9 === c.nodeType ? c : c.ownerDocument).createTextNode(d), d[wf] = b, b.stateNode = d)
            }
            return null;
        case 13:
            H(P);
            d = b.memoizedState;
            if (0 !== (b.flags & 64)) return b.lanes = c, b;
            d = null !== d;
            c = !1;
            null === a ? void 0 !== b.memoizedProps.fallback && rh(b) : c = null !== a.memoizedState;
            if (d && !c && 0 !== (b.mode & 2))
                if (null === a && !0 !== b.memoizedProps.unstable_avoidThisFallback || 0 !== (P.current & 1)) 0 === V && (V = 3);
                else {
                    if (0 === V || 3 === V) V =
                        4;
                    null === U || 0 === (Dg & 134217727) && 0 === (Hi & 134217727) || Ii(U, W)
                }
            if (d || c) b.flags |= 4;
            return null;
        case 4:
            return fh(), Ci(b), null === a && cf(b.stateNode.containerInfo), null;
        case 10:
            return rg(b), null;
        case 17:
            return Ff(b.type) && Gf(), null;
        case 19:
            H(P);
            d = b.memoizedState;
            if (null === d) return null;
            f = 0 !== (b.flags & 64);
            g = d.rendering;
            if (null === g)
                if (f) Fi(d, !1);
                else {
                    if (0 !== V || null !== a && 0 !== (a.flags & 64))
                        for (a = b.child; null !== a;) {
                            g = ih(a);
                            if (null !== g) {
                                b.flags |= 64;
                                Fi(d, !1);
                                f = g.updateQueue;
                                null !== f && (b.updateQueue = f, b.flags |= 4);
                                null === d.lastEffect && (b.firstEffect = null);
                                b.lastEffect = d.lastEffect;
                                d = c;
                                for (c = b.child; null !== c;) f = c, a = d, f.flags &= 2, f.nextEffect = null, f.firstEffect = null, f.lastEffect = null, g = f.alternate, null === g ? (f.childLanes = 0, f.lanes = a, f.child = null, f.memoizedProps = null, f.memoizedState = null, f.updateQueue = null, f.dependencies = null, f.stateNode = null) : (f.childLanes = g.childLanes, f.lanes = g.lanes, f.child = g.child, f.memoizedProps = g.memoizedProps, f.memoizedState = g.memoizedState, f.updateQueue = g.updateQueue, f.type = g.type, a = g.dependencies,
                                    f.dependencies = null === a ? null : {
                                        lanes: a.lanes,
                                        firstContext: a.firstContext
                                    }), c = c.sibling;
                                I(P, P.current & 1 | 2);
                                return b.child
                            }
                            a = a.sibling
                        }
                    null !== d.tail && O() > Ji && (b.flags |= 64, f = !0, Fi(d, !1), b.lanes = 33554432)
                } else {
                if (!f)
                    if (a = ih(g), null !== a) {
                        if (b.flags |= 64, f = !0, c = a.updateQueue, null !== c && (b.updateQueue = c, b.flags |= 4), Fi(d, !0), null === d.tail && "hidden" === d.tailMode && !g.alternate && !lh) return b = b.lastEffect = d.lastEffect, null !== b && (b.nextEffect = null), null
                    } else 2 * O() - d.renderingStartTime > Ji && 1073741824 !== c && (b.flags |=
                        64, f = !0, Fi(d, !1), b.lanes = 33554432);
                d.isBackwards ? (g.sibling = b.child, b.child = g) : (c = d.last, null !== c ? c.sibling = g : b.child = g, d.last = g)
            }
            return null !== d.tail ? (c = d.tail, d.rendering = c, d.tail = c.sibling, d.lastEffect = b.lastEffect, d.renderingStartTime = O(), c.sibling = null, b = P.current, I(P, f ? b & 1 | 2 : b & 1), c) : null;
        case 23:
        case 24:
            return Ki(), null !== a && null !== a.memoizedState !== (null !== b.memoizedState) && "unstable-defer-without-hiding" !== d.mode && (b.flags |= 4), null
    }
    throw Error(y(156, b.tag));
}

function Li(a) {
    switch (a.tag) {
        case 1:
            Ff(a.type) && Gf();
            var b = a.flags;
            return b & 4096 ? (a.flags = b & -4097 | 64, a) : null;
        case 3:
            fh();
            H(N);
            H(M);
            uh();
            b = a.flags;
            if (0 !== (b & 64)) throw Error(y(285));
            a.flags = b & -4097 | 64;
            return a;
        case 5:
            return hh(a), null;
        case 13:
            return H(P), b = a.flags, b & 4096 ? (a.flags = b & -4097 | 64, a) : null;
        case 19:
            return H(P), null;
        case 4:
            return fh(), null;
        case 10:
            return rg(a), null;
        case 23:
        case 24:
            return Ki(), null;
        default:
            return null
    }
}

function Mi(a, b) {
    try {
        var c = "",
            d = b;
        do c += Qa(d), d = d.return; while (d);
        var e = c
    } catch (f) {
        e = "\nError generating stack: " + f.message + "\n" + f.stack
    }
    return {
        value: a,
        source: b,
        stack: e
    }
}

function Ni(a, b) {
    try {
        console.error(b.value)
    } catch (c) {
        setTimeout(function() {
            throw c;
        })
    }
}
var Oi = "function" === typeof WeakMap ? WeakMap : Map;

function Pi(a, b, c) {
    c = zg(-1, c);
    c.tag = 3;
    c.payload = {
        element: null
    };
    var d = b.value;
    c.callback = function() {
        Qi || (Qi = !0, Ri = d);
        Ni(a, b)
    };
    return c
}

function Si(a, b, c) {
    c = zg(-1, c);
    c.tag = 3;
    var d = a.type.getDerivedStateFromError;
    if ("function" === typeof d) {
        var e = b.value;
        c.payload = function() {
            Ni(a, b);
            return d(e)
        }
    }
    var f = a.stateNode;
    null !== f && "function" === typeof f.componentDidCatch && (c.callback = function() {
        "function" !== typeof d && (null === Ti ? Ti = new Set([this]) : Ti.add(this), Ni(a, b));
        var c = b.stack;
        this.componentDidCatch(b.value, {
            componentStack: null !== c ? c : ""
        })
    });
    return c
}
var Ui = "function" === typeof WeakSet ? WeakSet : Set;

function Vi(a) {
    var b = a.ref;
    if (null !== b)
        if ("function" === typeof b) try {
            b(null)
        } catch (c) {
            Wi(a, c)
        } else b.current = null
}

function Xi(a, b) {
    switch (b.tag) {
        case 0:
        case 11:
        case 15:
        case 22:
            return;
        case 1:
            if (b.flags & 256 && null !== a) {
                var c = a.memoizedProps,
                    d = a.memoizedState;
                a = b.stateNode;
                b = a.getSnapshotBeforeUpdate(b.elementType === b.type ? c : lg(b.type, c), d);
                a.__reactInternalSnapshotBeforeUpdate = b
            }
            return;
        case 3:
            b.flags & 256 && qf(b.stateNode.containerInfo);
            return;
        case 5:
        case 6:
        case 4:
        case 17:
            return
    }
    throw Error(y(163));
}

function Yi(a, b, c) {
    switch (c.tag) {
        case 0:
        case 11:
        case 15:
        case 22:
            b = c.updateQueue;
            b = null !== b ? b.lastEffect : null;
            if (null !== b) {
                a = b = b.next;
                do {
                    if (3 === (a.tag & 3)) {
                        var d = a.create;
                        a.destroy = d()
                    }
                    a = a.next
                } while (a !== b)
            }
            b = c.updateQueue;
            b = null !== b ? b.lastEffect : null;
            if (null !== b) {
                a = b = b.next;
                do {
                    var e = a;
                    d = e.next;
                    e = e.tag;
                    0 !== (e & 4) && 0 !== (e & 1) && (Zi(c, a), $i(c, a));
                    a = d
                } while (a !== b)
            }
            return;
        case 1:
            a = c.stateNode;
            c.flags & 4 && (null === b ? a.componentDidMount() : (d = c.elementType === c.type ? b.memoizedProps : lg(c.type, b.memoizedProps), a.componentDidUpdate(d,
                b.memoizedState, a.__reactInternalSnapshotBeforeUpdate)));
            b = c.updateQueue;
            null !== b && Eg(c, b, a);
            return;
        case 3:
            b = c.updateQueue;
            if (null !== b) {
                a = null;
                if (null !== c.child) switch (c.child.tag) {
                    case 5:
                        a = c.child.stateNode;
                        break;
                    case 1:
                        a = c.child.stateNode
                }
                Eg(c, b, a)
            }
            return;
        case 5:
            a = c.stateNode;
            null === b && c.flags & 4 && mf(c.type, c.memoizedProps) && a.focus();
            return;
        case 6:
            return;
        case 4:
            return;
        case 12:
            return;
        case 13:
            null === c.memoizedState && (c = c.alternate, null !== c && (c = c.memoizedState, null !== c && (c = c.dehydrated, null !== c && Cc(c))));
            return;
        case 19:
        case 17:
        case 20:
        case 21:
        case 23:
        case 24:
            return
    }
    throw Error(y(163));
}

function aj(a, b) {
    for (var c = a;;) {
        if (5 === c.tag) {
            var d = c.stateNode;
            if (b) d = d.style, "function" === typeof d.setProperty ? d.setProperty("display", "none", "important") : d.display = "none";
            else {
                d = c.stateNode;
                var e = c.memoizedProps.style;
                e = void 0 !== e && null !== e && e.hasOwnProperty("display") ? e.display : null;
                d.style.display = sb("display", e)
            }
        } else if (6 === c.tag) c.stateNode.nodeValue = b ? "" : c.memoizedProps;
        else if ((23 !== c.tag && 24 !== c.tag || null === c.memoizedState || c === a) && null !== c.child) {
            c.child.return = c;
            c = c.child;
            continue
        }
        if (c ===
            a) break;
        for (; null === c.sibling;) {
            if (null === c.return || c.return === a) return;
            c = c.return
        }
        c.sibling.return = c.return;
        c = c.sibling
    }
}

function bj(a, b) {
    if (Mf && "function" === typeof Mf.onCommitFiberUnmount) try {
        Mf.onCommitFiberUnmount(Lf, b)
    } catch (f) {}
    switch (b.tag) {
        case 0:
        case 11:
        case 14:
        case 15:
        case 22:
            a = b.updateQueue;
            if (null !== a && (a = a.lastEffect, null !== a)) {
                var c = a = a.next;
                do {
                    var d = c,
                        e = d.destroy;
                    d = d.tag;
                    if (void 0 !== e)
                        if (0 !== (d & 4)) Zi(b, c);
                        else {
                            d = b;
                            try {
                                e()
                            } catch (f) {
                                Wi(d, f)
                            }
                        }
                    c = c.next
                } while (c !== a)
            }
            break;
        case 1:
            Vi(b);
            a = b.stateNode;
            if ("function" === typeof a.componentWillUnmount) try {
                a.props = b.memoizedProps, a.state = b.memoizedState, a.componentWillUnmount()
            } catch (f) {
                Wi(b,
                    f)
            }
            break;
        case 5:
            Vi(b);
            break;
        case 4:
            cj(a, b)
    }
}

function dj(a) {
    a.alternate = null;
    a.child = null;
    a.dependencies = null;
    a.firstEffect = null;
    a.lastEffect = null;
    a.memoizedProps = null;
    a.memoizedState = null;
    a.pendingProps = null;
    a.return = null;
    a.updateQueue = null
}

function ej(a) {
    return 5 === a.tag || 3 === a.tag || 4 === a.tag
}

function fj(a) {
    a: {
        for (var b = a.return; null !== b;) {
            if (ej(b)) break a;
            b = b.return
        }
        throw Error(y(160));
    }
    var c = b;b = c.stateNode;
    switch (c.tag) {
        case 5:
            var d = !1;
            break;
        case 3:
            b = b.containerInfo;
            d = !0;
            break;
        case 4:
            b = b.containerInfo;
            d = !0;
            break;
        default:
            throw Error(y(161));
    }
    c.flags & 16 && (pb(b, ""), c.flags &= -17);a: b: for (c = a;;) {
        for (; null === c.sibling;) {
            if (null === c.return || ej(c.return)) {
                c = null;
                break a
            }
            c = c.return
        }
        c.sibling.return = c.return;
        for (c = c.sibling; 5 !== c.tag && 6 !== c.tag && 18 !== c.tag;) {
            if (c.flags & 2) continue b;
            if (null ===
                c.child || 4 === c.tag) continue b;
            else c.child.return = c, c = c.child
        }
        if (!(c.flags & 2)) {
            c = c.stateNode;
            break a
        }
    }
    d ? gj(a, c, b) : hj(a, c, b)
}

function gj(a, b, c) {
    var d = a.tag,
        e = 5 === d || 6 === d;
    if (e) a = e ? a.stateNode : a.stateNode.instance, b ? 8 === c.nodeType ? c.parentNode.insertBefore(a, b) : c.insertBefore(a, b) : (8 === c.nodeType ? (b = c.parentNode, b.insertBefore(a, c)) : (b = c, b.appendChild(a)), c = c._reactRootContainer, null !== c && void 0 !== c || null !== b.onclick || (b.onclick = jf));
    else if (4 !== d && (a = a.child, null !== a))
        for (gj(a, b, c), a = a.sibling; null !== a;) gj(a, b, c), a = a.sibling
}

function hj(a, b, c) {
    var d = a.tag,
        e = 5 === d || 6 === d;
    if (e) a = e ? a.stateNode : a.stateNode.instance, b ? c.insertBefore(a, b) : c.appendChild(a);
    else if (4 !== d && (a = a.child, null !== a))
        for (hj(a, b, c), a = a.sibling; null !== a;) hj(a, b, c), a = a.sibling
}

function cj(a, b) {
    for (var c = b, d = !1, e, f;;) {
        if (!d) {
            d = c.return;
            a: for (;;) {
                if (null === d) throw Error(y(160));
                e = d.stateNode;
                switch (d.tag) {
                    case 5:
                        f = !1;
                        break a;
                    case 3:
                        e = e.containerInfo;
                        f = !0;
                        break a;
                    case 4:
                        e = e.containerInfo;
                        f = !0;
                        break a
                }
                d = d.return
            }
            d = !0
        }
        if (5 === c.tag || 6 === c.tag) {
            a: for (var g = a, h = c, k = h;;)
                if (bj(g, k), null !== k.child && 4 !== k.tag) k.child.return = k, k = k.child;
                else {
                    if (k === h) break a;
                    for (; null === k.sibling;) {
                        if (null === k.return || k.return === h) break a;
                        k = k.return
                    }
                    k.sibling.return = k.return;
                    k = k.sibling
                }f ? (g = e, h = c.stateNode,
                8 === g.nodeType ? g.parentNode.removeChild(h) : g.removeChild(h)) : e.removeChild(c.stateNode)
        } else if (4 === c.tag) {
            if (null !== c.child) {
                e = c.stateNode.containerInfo;
                f = !0;
                c.child.return = c;
                c = c.child;
                continue
            }
        } else if (bj(a, c), null !== c.child) {
            c.child.return = c;
            c = c.child;
            continue
        }
        if (c === b) break;
        for (; null === c.sibling;) {
            if (null === c.return || c.return === b) return;
            c = c.return;
            4 === c.tag && (d = !1)
        }
        c.sibling.return = c.return;
        c = c.sibling
    }
}

function ij(a, b) {
    switch (b.tag) {
        case 0:
        case 11:
        case 14:
        case 15:
        case 22:
            var c = b.updateQueue;
            c = null !== c ? c.lastEffect : null;
            if (null !== c) {
                var d = c = c.next;
                do 3 === (d.tag & 3) && (a = d.destroy, d.destroy = void 0, void 0 !== a && a()), d = d.next; while (d !== c)
            }
            return;
        case 1:
            return;
        case 5:
            c = b.stateNode;
            if (null != c) {
                d = b.memoizedProps;
                var e = null !== a ? a.memoizedProps : d;
                a = b.type;
                var f = b.updateQueue;
                b.updateQueue = null;
                if (null !== f) {
                    c[xf] = d;
                    "input" === a && "radio" === d.type && null != d.name && $a(c, d);
                    wb(a, e);
                    b = wb(a, d);
                    for (e = 0; e < f.length; e +=
                        2) {
                        var g = f[e],
                            h = f[e + 1];
                        "style" === g ? tb(c, h) : "dangerouslySetInnerHTML" === g ? ob(c, h) : "children" === g ? pb(c, h) : qa(c, g, h, b)
                    }
                    switch (a) {
                        case "input":
                            ab(c, d);
                            break;
                        case "textarea":
                            ib(c, d);
                            break;
                        case "select":
                            a = c._wrapperState.wasMultiple, c._wrapperState.wasMultiple = !!d.multiple, f = d.value, null != f ? fb(c, !!d.multiple, f, !1) : a !== !!d.multiple && (null != d.defaultValue ? fb(c, !!d.multiple, d.defaultValue, !0) : fb(c, !!d.multiple, d.multiple ? [] : "", !1))
                    }
                }
            }
            return;
        case 6:
            if (null === b.stateNode) throw Error(y(162));
            b.stateNode.nodeValue =
                b.memoizedProps;
            return;
        case 3:
            c = b.stateNode;
            c.hydrate && (c.hydrate = !1, Cc(c.containerInfo));
            return;
        case 12:
            return;
        case 13:
            null !== b.memoizedState && (jj = O(), aj(b.child, !0));
            kj(b);
            return;
        case 19:
            kj(b);
            return;
        case 17:
            return;
        case 23:
        case 24:
            aj(b, null !== b.memoizedState);
            return
    }
    throw Error(y(163));
}

function kj(a) {
    var b = a.updateQueue;
    if (null !== b) {
        a.updateQueue = null;
        var c = a.stateNode;
        null === c && (c = a.stateNode = new Ui);
        b.forEach(function(b) {
            var d = lj.bind(null, a, b);
            c.has(b) || (c.add(b), b.then(d, d))
        })
    }
}

function mj(a, b) {
    return null !== a && (a = a.memoizedState, null === a || null !== a.dehydrated) ? (b = b.memoizedState, null !== b && null === b.dehydrated) : !1
}
var nj = Math.ceil,
    oj = ra.ReactCurrentDispatcher,
    pj = ra.ReactCurrentOwner,
    X = 0,
    U = null,
    Y = null,
    W = 0,
    qj = 0,
    rj = Bf(0),
    V = 0,
    sj = null,
    tj = 0,
    Dg = 0,
    Hi = 0,
    uj = 0,
    vj = null,
    jj = 0,
    Ji = Infinity;

function wj() {
    Ji = O() + 500
}
var Z = null,
    Qi = !1,
    Ri = null,
    Ti = null,
    xj = !1,
    yj = null,
    zj = 90,
    Aj = [],
    Bj = [],
    Cj = null,
    Dj = 0,
    Ej = null,
    Fj = -1,
    Gj = 0,
    Hj = 0,
    Ij = null,
    Jj = !1;

function Hg() {
    return 0 !== (X & 48) ? O() : -1 !== Fj ? Fj : Fj = O()
}

function Ig(a) {
    a = a.mode;
    if (0 === (a & 2)) return 1;
    if (0 === (a & 4)) return 99 === eg() ? 1 : 2;
    0 === Gj && (Gj = tj);
    if (0 !== kg.transition) {
        0 !== Hj && (Hj = null !== vj ? vj.pendingLanes : 0);
        a = Gj;
        var b = 4186112 & ~Hj;
        b &= -b;
        0 === b && (a = 4186112 & ~a, b = a & -a, 0 === b && (b = 8192));
        return b
    }
    a = eg();
    0 !== (X & 4) && 98 === a ? a = Xc(12, Gj) : (a = Sc(a), a = Xc(a, Gj));
    return a
}

function Jg(a, b, c) {
    if (50 < Dj) throw Dj = 0, Ej = null, Error(y(185));
    a = Kj(a, b);
    if (null === a) return null;
    $c(a, b, c);
    a === U && (Hi |= b, 4 === V && Ii(a, W));
    var d = eg();
    1 === b ? 0 !== (X & 8) && 0 === (X & 48) ? Lj(a) : (Mj(a, c), 0 === X && (wj(), ig())) : (0 === (X & 4) || 98 !== d && 99 !== d || (null === Cj ? Cj = new Set([a]) : Cj.add(a)), Mj(a, c));
    vj = a
}

function Kj(a, b) {
    a.lanes |= b;
    var c = a.alternate;
    null !== c && (c.lanes |= b);
    c = a;
    for (a = a.return; null !== a;) a.childLanes |= b, c = a.alternate, null !== c && (c.childLanes |= b), c = a, a = a.return;
    return 3 === c.tag ? c.stateNode : null
}

function Mj(a, b) {
    for (var c = a.callbackNode, d = a.suspendedLanes, e = a.pingedLanes, f = a.expirationTimes, g = a.pendingLanes; 0 < g;) {
        var h = 31 - Vc(g),
            k = 1 << h,
            l = f[h];
        if (-1 === l) {
            if (0 === (k & d) || 0 !== (k & e)) {
                l = b;
                Rc(k);
                var n = F;
                f[h] = 10 <= n ? l + 250 : 6 <= n ? l + 5E3 : -1
            }
        } else l <= b && (a.expiredLanes |= k);
        g &= ~k
    }
    d = Uc(a, a === U ? W : 0);
    b = F;
    if (0 === d) null !== c && (c !== Zf && Pf(c), a.callbackNode = null, a.callbackPriority = 0);
    else {
        if (null !== c) {
            if (a.callbackPriority === b) return;
            c !== Zf && Pf(c)
        }
        15 === b ? (c = Lj.bind(null, a), null === ag ? (ag = [c], bg = Of(Uf, jg)) : ag.push(c),
            c = Zf) : 14 === b ? c = hg(99, Lj.bind(null, a)) : (c = Tc(b), c = hg(c, Nj.bind(null, a)));
        a.callbackPriority = b;
        a.callbackNode = c
    }
}

function Nj(a) {
    Fj = -1;
    Hj = Gj = 0;
    if (0 !== (X & 48)) throw Error(y(327));
    var b = a.callbackNode;
    if (Oj() && a.callbackNode !== b) return null;
    var c = Uc(a, a === U ? W : 0);
    if (0 === c) return null;
    var d = c;
    var e = X;
    X |= 16;
    var f = Pj();
    if (U !== a || W !== d) wj(), Qj(a, d);
    do try {
        Rj();
        break
    } catch (h) {
        Sj(a, h)
    }
    while (1);
    qg();
    oj.current = f;
    X = e;
    null !== Y ? d = 0 : (U = null, W = 0, d = V);
    if (0 !== (tj & Hi)) Qj(a, 0);
    else if (0 !== d) {
        2 === d && (X |= 64, a.hydrate && (a.hydrate = !1, qf(a.containerInfo)), c = Wc(a), 0 !== c && (d = Tj(a, c)));
        if (1 === d) throw b = sj, Qj(a, 0), Ii(a, c), Mj(a, O()), b;
        a.finishedWork =
            a.current.alternate;
        a.finishedLanes = c;
        switch (d) {
            case 0:
            case 1:
                throw Error(y(345));
            case 2:
                Uj(a);
                break;
            case 3:
                Ii(a, c);
                if ((c & 62914560) === c && (d = jj + 500 - O(), 10 < d)) {
                    if (0 !== Uc(a, 0)) break;
                    e = a.suspendedLanes;
                    if ((e & c) !== c) {
                        Hg();
                        a.pingedLanes |= a.suspendedLanes & e;
                        break
                    }
                    a.timeoutHandle = of(Uj.bind(null, a), d);
                    break
                }
                Uj(a);
                break;
            case 4:
                Ii(a, c);
                if ((c & 4186112) === c) break;
                d = a.eventTimes;
                for (e = -1; 0 < c;) {
                    var g = 31 - Vc(c);
                    f = 1 << g;
                    g = d[g];
                    g > e && (e = g);
                    c &= ~f
                }
                c = e;
                c = O() - c;
                c = (120 > c ? 120 : 480 > c ? 480 : 1080 > c ? 1080 : 1920 > c ? 1920 : 3E3 > c ? 3E3 : 4320 >
                    c ? 4320 : 1960 * nj(c / 1960)) - c;
                if (10 < c) {
                    a.timeoutHandle = of(Uj.bind(null, a), c);
                    break
                }
                Uj(a);
                break;
            case 5:
                Uj(a);
                break;
            default:
                throw Error(y(329));
        }
    }
    Mj(a, O());
    return a.callbackNode === b ? Nj.bind(null, a) : null
}

function Ii(a, b) {
    b &= ~uj;
    b &= ~Hi;
    a.suspendedLanes |= b;
    a.pingedLanes &= ~b;
    for (a = a.expirationTimes; 0 < b;) {
        var c = 31 - Vc(b),
            d = 1 << c;
        a[c] = -1;
        b &= ~d
    }
}

function Lj(a) {
    if (0 !== (X & 48)) throw Error(y(327));
    Oj();
    if (a === U && 0 !== (a.expiredLanes & W)) {
        var b = W;
        var c = Tj(a, b);
        0 !== (tj & Hi) && (b = Uc(a, b), c = Tj(a, b))
    } else b = Uc(a, 0), c = Tj(a, b);
    0 !== a.tag && 2 === c && (X |= 64, a.hydrate && (a.hydrate = !1, qf(a.containerInfo)), b = Wc(a), 0 !== b && (c = Tj(a, b)));
    if (1 === c) throw c = sj, Qj(a, 0), Ii(a, b), Mj(a, O()), c;
    a.finishedWork = a.current.alternate;
    a.finishedLanes = b;
    Uj(a);
    Mj(a, O());
    return null
}

function Vj() {
    if (null !== Cj) {
        var a = Cj;
        Cj = null;
        a.forEach(function(a) {
            a.expiredLanes |= 24 & a.pendingLanes;
            Mj(a, O())
        })
    }
    ig()
}

function Wj(a, b) {
    var c = X;
    X |= 1;
    try {
        return a(b)
    } finally {
        X = c, 0 === X && (wj(), ig())
    }
}

function Xj(a, b) {
    var c = X;
    X &= -2;
    X |= 8;
    try {
        return a(b)
    } finally {
        X = c, 0 === X && (wj(), ig())
    }
}

function ni(a, b) {
    I(rj, qj);
    qj |= b;
    tj |= b
}

function Ki() {
    qj = rj.current;
    H(rj)
}

function Qj(a, b) {
    a.finishedWork = null;
    a.finishedLanes = 0;
    var c = a.timeoutHandle; - 1 !== c && (a.timeoutHandle = -1, pf(c));
    if (null !== Y)
        for (c = Y.return; null !== c;) {
            var d = c;
            switch (d.tag) {
                case 1:
                    d = d.type.childContextTypes;
                    null !== d && void 0 !== d && Gf();
                    break;
                case 3:
                    fh();
                    H(N);
                    H(M);
                    uh();
                    break;
                case 5:
                    hh(d);
                    break;
                case 4:
                    fh();
                    break;
                case 13:
                    H(P);
                    break;
                case 19:
                    H(P);
                    break;
                case 10:
                    rg(d);
                    break;
                case 23:
                case 24:
                    Ki()
            }
            c = c.return
        }
    U = a;
    Y = Tg(a.current, null);
    W = qj = tj = b;
    V = 0;
    sj = null;
    uj = Hi = Dg = 0
}

function Sj(a, b) {
    do {
        var c = Y;
        try {
            qg();
            vh.current = Gh;
            if (yh) {
                for (var d = R.memoizedState; null !== d;) {
                    var e = d.queue;
                    null !== e && (e.pending = null);
                    d = d.next
                }
                yh = !1
            }
            xh = 0;
            T = S = R = null;
            zh = !1;
            pj.current = null;
            if (null === c || null === c.return) {
                V = 1;
                sj = b;
                Y = null;
                break
            }
            a: {
                var f = a,
                    g = c.return,
                    h = c,
                    k = b;
                b = W;
                h.flags |= 2048;
                h.firstEffect = h.lastEffect = null;
                if (null !== k && "object" === typeof k && "function" === typeof k.then) {
                    var l = k;
                    if (0 === (h.mode & 2)) {
                        var n = h.alternate;
                        n ? (h.updateQueue = n.updateQueue, h.memoizedState = n.memoizedState, h.lanes = n.lanes) :
                            (h.updateQueue = null, h.memoizedState = null)
                    }
                    var A = 0 !== (P.current & 1),
                        p = g;
                    do {
                        var C;
                        if (C = 13 === p.tag) {
                            var x = p.memoizedState;
                            if (null !== x) C = null !== x.dehydrated ? !0 : !1;
                            else {
                                var w = p.memoizedProps;
                                C = void 0 === w.fallback ? !1 : !0 !== w.unstable_avoidThisFallback ? !0 : A ? !1 : !0
                            }
                        }
                        if (C) {
                            var z = p.updateQueue;
                            if (null === z) {
                                var u = new Set;
                                u.add(l);
                                p.updateQueue = u
                            } else z.add(l);
                            if (0 === (p.mode & 2)) {
                                p.flags |= 64;
                                h.flags |= 16384;
                                h.flags &= -2981;
                                if (1 === h.tag)
                                    if (null === h.alternate) h.tag = 17;
                                    else {
                                        var t = zg(-1, 1);
                                        t.tag = 2;
                                        Ag(h, t)
                                    }
                                h.lanes |= 1;
                                break a
                            }
                            k =
                                void 0;
                            h = b;
                            var q = f.pingCache;
                            null === q ? (q = f.pingCache = new Oi, k = new Set, q.set(l, k)) : (k = q.get(l), void 0 === k && (k = new Set, q.set(l, k)));
                            if (!k.has(h)) {
                                k.add(h);
                                var v = Yj.bind(null, f, l, h);
                                l.then(v, v)
                            }
                            p.flags |= 4096;
                            p.lanes = b;
                            break a
                        }
                        p = p.return
                    } while (null !== p);
                    k = Error((Ra(h.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display.")
                }
                5 !== V && (V = 2);
                k = Mi(k, h);
                p =
                    g;
                do {
                    switch (p.tag) {
                        case 3:
                            f = k;
                            p.flags |= 4096;
                            b &= -b;
                            p.lanes |= b;
                            var J = Pi(p, f, b);
                            Bg(p, J);
                            break a;
                        case 1:
                            f = k;
                            var K = p.type,
                                Q = p.stateNode;
                            if (0 === (p.flags & 64) && ("function" === typeof K.getDerivedStateFromError || null !== Q && "function" === typeof Q.componentDidCatch && (null === Ti || !Ti.has(Q)))) {
                                p.flags |= 4096;
                                b &= -b;
                                p.lanes |= b;
                                var L = Si(p, f, b);
                                Bg(p, L);
                                break a
                            }
                    }
                    p = p.return
                } while (null !== p)
            }
            Zj(c)
        } catch (va) {
            b = va;
            Y === c && null !== c && (Y = c = c.return);
            continue
        }
        break
    } while (1)
}

function Pj() {
    var a = oj.current;
    oj.current = Gh;
    return null === a ? Gh : a
}

function Tj(a, b) {
    var c = X;
    X |= 16;
    var d = Pj();
    U === a && W === b || Qj(a, b);
    do try {
        ak();
        break
    } catch (e) {
        Sj(a, e)
    }
    while (1);
    qg();
    X = c;
    oj.current = d;
    if (null !== Y) throw Error(y(261));
    U = null;
    W = 0;
    return V
}

function ak() {
    for (; null !== Y;) bk(Y)
}

function Rj() {
    for (; null !== Y && !Qf();) bk(Y)
}

function bk(a) {
    var b = ck(a.alternate, a, qj);
    a.memoizedProps = a.pendingProps;
    null === b ? Zj(a) : Y = b;
    pj.current = null
}

function Zj(a) {
    var b = a;
    do {
        var c = b.alternate;
        a = b.return;
        if (0 === (b.flags & 2048)) {
            c = Gi(c, b, qj);
            if (null !== c) {
                Y = c;
                return
            }
            c = b;
            if (24 !== c.tag && 23 !== c.tag || null === c.memoizedState || 0 !== (qj & 1073741824) || 0 === (c.mode & 4)) {
                for (var d = 0, e = c.child; null !== e;) d |= e.lanes | e.childLanes, e = e.sibling;
                c.childLanes = d
            }
            null !== a && 0 === (a.flags & 2048) && (null === a.firstEffect && (a.firstEffect = b.firstEffect), null !== b.lastEffect && (null !== a.lastEffect && (a.lastEffect.nextEffect = b.firstEffect), a.lastEffect = b.lastEffect), 1 < b.flags && (null !==
                a.lastEffect ? a.lastEffect.nextEffect = b : a.firstEffect = b, a.lastEffect = b))
        } else {
            c = Li(b);
            if (null !== c) {
                c.flags &= 2047;
                Y = c;
                return
            }
            null !== a && (a.firstEffect = a.lastEffect = null, a.flags |= 2048)
        }
        b = b.sibling;
        if (null !== b) {
            Y = b;
            return
        }
        Y = b = a
    } while (null !== b);
    0 === V && (V = 5)
}

function Uj(a) {
    var b = eg();
    gg(99, dk.bind(null, a, b));
    return null
}

function dk(a, b) {
    do Oj(); while (null !== yj);
    if (0 !== (X & 48)) throw Error(y(327));
    var c = a.finishedWork;
    if (null === c) return null;
    a.finishedWork = null;
    a.finishedLanes = 0;
    if (c === a.current) throw Error(y(177));
    a.callbackNode = null;
    var d = c.lanes | c.childLanes,
        e = d,
        f = a.pendingLanes & ~e;
    a.pendingLanes = e;
    a.suspendedLanes = 0;
    a.pingedLanes = 0;
    a.expiredLanes &= e;
    a.mutableReadLanes &= e;
    a.entangledLanes &= e;
    e = a.entanglements;
    for (var g = a.eventTimes, h = a.expirationTimes; 0 < f;) {
        var k = 31 - Vc(f),
            l = 1 << k;
        e[k] = 0;
        g[k] = -1;
        h[k] = -1;
        f &= ~l
    }
    null !==
        Cj && 0 === (d & 24) && Cj.has(a) && Cj.delete(a);
    a === U && (Y = U = null, W = 0);
    1 < c.flags ? null !== c.lastEffect ? (c.lastEffect.nextEffect = c, d = c.firstEffect) : d = c : d = c.firstEffect;
    if (null !== d) {
        e = X;
        X |= 32;
        pj.current = null;
        kf = fd;
        g = Ne();
        if (Oe(g)) {
            if ("selectionStart" in g) h = {
                start: g.selectionStart,
                end: g.selectionEnd
            };
            else a: if (h = (h = g.ownerDocument) && h.defaultView || window, (l = h.getSelection && h.getSelection()) && 0 !== l.rangeCount) {
                h = l.anchorNode;
                f = l.anchorOffset;
                k = l.focusNode;
                l = l.focusOffset;
                try {
                    h.nodeType, k.nodeType
                } catch (va) {
                    h = null;
                    break a
                }
                var n = 0,
                    A = -1,
                    p = -1,
                    C = 0,
                    x = 0,
                    w = g,
                    z = null;
                b: for (;;) {
                    for (var u;;) {
                        w !== h || 0 !== f && 3 !== w.nodeType || (A = n + f);
                        w !== k || 0 !== l && 3 !== w.nodeType || (p = n + l);
                        3 === w.nodeType && (n += w.nodeValue.length);
                        if (null === (u = w.firstChild)) break;
                        z = w;
                        w = u
                    }
                    for (;;) {
                        if (w === g) break b;
                        z === h && ++C === f && (A = n);
                        z === k && ++x === l && (p = n);
                        if (null !== (u = w.nextSibling)) break;
                        w = z;
                        z = w.parentNode
                    }
                    w = u
                }
                h = -1 === A || -1 === p ? null : {
                    start: A,
                    end: p
                }
            } else h = null;
            h = h || {
                start: 0,
                end: 0
            }
        } else h = null;
        lf = {
            focusedElem: g,
            selectionRange: h
        };
        fd = !1;
        Ij = null;
        Jj = !1;
        Z = d;
        do try {
            ek()
        } catch (va) {
            if (null ===
                Z) throw Error(y(330));
            Wi(Z, va);
            Z = Z.nextEffect
        }
        while (null !== Z);
        Ij = null;
        Z = d;
        do try {
            for (g = a; null !== Z;) {
                var t = Z.flags;
                t & 16 && pb(Z.stateNode, "");
                if (t & 128) {
                    var q = Z.alternate;
                    if (null !== q) {
                        var v = q.ref;
                        null !== v && ("function" === typeof v ? v(null) : v.current = null)
                    }
                }
                switch (t & 1038) {
                    case 2:
                        fj(Z);
                        Z.flags &= -3;
                        break;
                    case 6:
                        fj(Z);
                        Z.flags &= -3;
                        ij(Z.alternate, Z);
                        break;
                    case 1024:
                        Z.flags &= -1025;
                        break;
                    case 1028:
                        Z.flags &= -1025;
                        ij(Z.alternate, Z);
                        break;
                    case 4:
                        ij(Z.alternate, Z);
                        break;
                    case 8:
                        h = Z;
                        cj(g, h);
                        var J = h.alternate;
                        dj(h);
                        null !==
                            J && dj(J)
                }
                Z = Z.nextEffect
            }
        } catch (va) {
            if (null === Z) throw Error(y(330));
            Wi(Z, va);
            Z = Z.nextEffect
        }
        while (null !== Z);
        v = lf;
        q = Ne();
        t = v.focusedElem;
        g = v.selectionRange;
        if (q !== t && t && t.ownerDocument && Me(t.ownerDocument.documentElement, t)) {
            null !== g && Oe(t) && (q = g.start, v = g.end, void 0 === v && (v = q), "selectionStart" in t ? (t.selectionStart = q, t.selectionEnd = Math.min(v, t.value.length)) : (v = (q = t.ownerDocument || document) && q.defaultView || window, v.getSelection && (v = v.getSelection(), h = t.textContent.length, J = Math.min(g.start, h), g = void 0 ===
                g.end ? J : Math.min(g.end, h), !v.extend && J > g && (h = g, g = J, J = h), h = Le(t, J), f = Le(t, g), h && f && (1 !== v.rangeCount || v.anchorNode !== h.node || v.anchorOffset !== h.offset || v.focusNode !== f.node || v.focusOffset !== f.offset) && (q = q.createRange(), q.setStart(h.node, h.offset), v.removeAllRanges(), J > g ? (v.addRange(q), v.extend(f.node, f.offset)) : (q.setEnd(f.node, f.offset), v.addRange(q))))));
            q = [];
            for (v = t; v = v.parentNode;) 1 === v.nodeType && q.push({
                element: v,
                left: v.scrollLeft,
                top: v.scrollTop
            });
            "function" === typeof t.focus && t.focus();
            for (t =
                0; t < q.length; t++) v = q[t], v.element.scrollLeft = v.left, v.element.scrollTop = v.top
        }
        fd = !!kf;
        lf = kf = null;
        a.current = c;
        Z = d;
        do try {
            for (t = a; null !== Z;) {
                var K = Z.flags;
                K & 36 && Yi(t, Z.alternate, Z);
                if (K & 128) {
                    q = void 0;
                    var Q = Z.ref;
                    if (null !== Q) {
                        var L = Z.stateNode;
                        switch (Z.tag) {
                            case 5:
                                q = L;
                                break;
                            default:
                                q = L
                        }
                        "function" === typeof Q ? Q(q) : Q.current = q
                    }
                }
                Z = Z.nextEffect
            }
        } catch (va) {
            if (null === Z) throw Error(y(330));
            Wi(Z, va);
            Z = Z.nextEffect
        }
        while (null !== Z);
        Z = null;
        $f();
        X = e
    } else a.current = c;
    if (xj) xj = !1, yj = a, zj = b;
    else
        for (Z = d; null !== Z;) b =
            Z.nextEffect, Z.nextEffect = null, Z.flags & 8 && (K = Z, K.sibling = null, K.stateNode = null), Z = b;
    d = a.pendingLanes;
    0 === d && (Ti = null);
    1 === d ? a === Ej ? Dj++ : (Dj = 0, Ej = a) : Dj = 0;
    c = c.stateNode;
    if (Mf && "function" === typeof Mf.onCommitFiberRoot) try {
        Mf.onCommitFiberRoot(Lf, c, void 0, 64 === (c.current.flags & 64))
    } catch (va) {}
    Mj(a, O());
    if (Qi) throw Qi = !1, a = Ri, Ri = null, a;
    if (0 !== (X & 8)) return null;
    ig();
    return null
}

function ek() {
    for (; null !== Z;) {
        var a = Z.alternate;
        Jj || null === Ij || (0 !== (Z.flags & 8) ? dc(Z, Ij) && (Jj = !0) : 13 === Z.tag && mj(a, Z) && dc(Z, Ij) && (Jj = !0));
        var b = Z.flags;
        0 !== (b & 256) && Xi(a, Z);
        0 === (b & 512) || xj || (xj = !0, hg(97, function() {
            Oj();
            return null
        }));
        Z = Z.nextEffect
    }
}

function Oj() {
    if (90 !== zj) {
        var a = 97 < zj ? 97 : zj;
        zj = 90;
        return gg(a, fk)
    }
    return !1
}

function $i(a, b) {
    Aj.push(b, a);
    xj || (xj = !0, hg(97, function() {
        Oj();
        return null
    }))
}

function Zi(a, b) {
    Bj.push(b, a);
    xj || (xj = !0, hg(97, function() {
        Oj();
        return null
    }))
}

function fk() {
    if (null === yj) return !1;
    var a = yj;
    yj = null;
    if (0 !== (X & 48)) throw Error(y(331));
    var b = X;
    X |= 32;
    var c = Bj;
    Bj = [];
    for (var d = 0; d < c.length; d += 2) {
        var e = c[d],
            f = c[d + 1],
            g = e.destroy;
        e.destroy = void 0;
        if ("function" === typeof g) try {
            g()
        } catch (k) {
            if (null === f) throw Error(y(330));
            Wi(f, k)
        }
    }
    c = Aj;
    Aj = [];
    for (d = 0; d < c.length; d += 2) {
        e = c[d];
        f = c[d + 1];
        try {
            var h = e.create;
            e.destroy = h()
        } catch (k) {
            if (null === f) throw Error(y(330));
            Wi(f, k)
        }
    }
    for (h = a.current.firstEffect; null !== h;) a = h.nextEffect, h.nextEffect = null, h.flags & 8 && (h.sibling =
        null, h.stateNode = null), h = a;
    X = b;
    ig();
    return !0
}

function gk(a, b, c) {
    b = Mi(c, b);
    b = Pi(a, b, 1);
    Ag(a, b);
    b = Hg();
    a = Kj(a, 1);
    null !== a && ($c(a, 1, b), Mj(a, b))
}

function Wi(a, b) {
    if (3 === a.tag) gk(a, a, b);
    else
        for (var c = a.return; null !== c;) {
            if (3 === c.tag) {
                gk(c, a, b);
                break
            } else if (1 === c.tag) {
                var d = c.stateNode;
                if ("function" === typeof c.type.getDerivedStateFromError || "function" === typeof d.componentDidCatch && (null === Ti || !Ti.has(d))) {
                    a = Mi(b, a);
                    var e = Si(c, a, 1);
                    Ag(c, e);
                    e = Hg();
                    c = Kj(c, 1);
                    if (null !== c) $c(c, 1, e), Mj(c, e);
                    else if ("function" === typeof d.componentDidCatch && (null === Ti || !Ti.has(d))) try {
                        d.componentDidCatch(b, a)
                    } catch (f) {}
                    break
                }
            }
            c = c.return
        }
}

function Yj(a, b, c) {
    var d = a.pingCache;
    null !== d && d.delete(b);
    b = Hg();
    a.pingedLanes |= a.suspendedLanes & c;
    U === a && (W & c) === c && (4 === V || 3 === V && (W & 62914560) === W && 500 > O() - jj ? Qj(a, 0) : uj |= c);
    Mj(a, b)
}

function lj(a, b) {
    var c = a.stateNode;
    null !== c && c.delete(b);
    b = 0;
    0 === b && (b = a.mode, 0 === (b & 2) ? b = 1 : 0 === (b & 4) ? b = 99 === eg() ? 1 : 2 : (0 === Gj && (Gj = tj), b = Yc(62914560 & ~Gj), 0 === b && (b = 4194304)));
    c = Hg();
    a = Kj(a, b);
    null !== a && ($c(a, b, c), Mj(a, c))
}
var ck;
ck = function(a, b, c) {
    var d = b.lanes;
    if (null !== a)
        if (a.memoizedProps !== b.pendingProps || N.current) ug = !0;
        else if (0 !== (c & d)) ug = 0 !== (a.flags & 16384) ? !0 : !1;
    else {
        ug = !1;
        switch (b.tag) {
            case 3:
                ri(b);
                sh();
                break;
            case 5:
                gh(b);
                break;
            case 1:
                Ff(b.type) && Jf(b);
                break;
            case 4:
                eh(b, b.stateNode.containerInfo);
                break;
            case 10:
                d = b.memoizedProps.value;
                var e = b.type._context;
                I(mg, e._currentValue);
                e._currentValue = d;
                break;
            case 13:
                if (null !== b.memoizedState) {
                    if (0 !== (c & b.child.childLanes)) return ti(a, b, c);
                    I(P, P.current & 1);
                    b = hi(a, b, c);
                    return null !==
                        b ? b.sibling : null
                }
                I(P, P.current & 1);
                break;
            case 19:
                d = 0 !== (c & b.childLanes);
                if (0 !== (a.flags & 64)) {
                    if (d) return Ai(a, b, c);
                    b.flags |= 64
                }
                e = b.memoizedState;
                null !== e && (e.rendering = null, e.tail = null, e.lastEffect = null);
                I(P, P.current);
                if (d) break;
                else return null;
            case 23:
            case 24:
                return b.lanes = 0, mi(a, b, c)
        }
        return hi(a, b, c)
    } else ug = !1;
    b.lanes = 0;
    switch (b.tag) {
        case 2:
            d = b.type;
            null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2);
            a = b.pendingProps;
            e = Ef(b, M.current);
            tg(b, c);
            e = Ch(null, b, d, a, e, c);
            b.flags |= 1;
            if ("object" ===
                typeof e && null !== e && "function" === typeof e.render && void 0 === e.$$typeof) {
                b.tag = 1;
                b.memoizedState = null;
                b.updateQueue = null;
                if (Ff(d)) {
                    var f = !0;
                    Jf(b)
                } else f = !1;
                b.memoizedState = null !== e.state && void 0 !== e.state ? e.state : null;
                xg(b);
                var g = d.getDerivedStateFromProps;
                "function" === typeof g && Gg(b, d, g, a);
                e.updater = Kg;
                b.stateNode = e;
                e._reactInternals = b;
                Og(b, d, a, c);
                b = qi(null, b, d, !0, f, c)
            } else b.tag = 0, fi(null, b, e, c), b = b.child;
            return b;
        case 16:
            e = b.elementType;
            a: {
                null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2);
                a = b.pendingProps;
                f = e._init;
                e = f(e._payload);
                b.type = e;
                f = b.tag = hk(e);
                a = lg(e, a);
                switch (f) {
                    case 0:
                        b = li(null, b, e, a, c);
                        break a;
                    case 1:
                        b = pi(null, b, e, a, c);
                        break a;
                    case 11:
                        b = gi(null, b, e, a, c);
                        break a;
                    case 14:
                        b = ii(null, b, e, lg(e.type, a), d, c);
                        break a
                }
                throw Error(y(306, e, ""));
            }
            return b;
        case 0:
            return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : lg(d, e), li(a, b, d, e, c);
        case 1:
            return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : lg(d, e), pi(a, b, d, e, c);
        case 3:
            ri(b);
            d = b.updateQueue;
            if (null === a || null === d) throw Error(y(282));
            d = b.pendingProps;
            e = b.memoizedState;
            e = null !== e ? e.element : null;
            yg(a, b);
            Cg(b, d, null, c);
            d = b.memoizedState.element;
            if (d === e) sh(), b = hi(a, b, c);
            else {
                e = b.stateNode;
                if (f = e.hydrate) kh = rf(b.stateNode.containerInfo.firstChild), jh = b, f = lh = !0;
                if (f) {
                    a = e.mutableSourceEagerHydrationData;
                    if (null != a)
                        for (e = 0; e < a.length; e += 2) f = a[e], f._workInProgressVersionPrimary = a[e + 1], th.push(f);
                    c = Zg(b, null, d, c);
                    for (b.child = c; c;) c.flags = c.flags & -3 | 1024, c = c.sibling
                } else fi(a, b, d, c), sh();
                b = b.child
            }
            return b;
        case 5:
            return gh(b), null === a &&
                ph(b), d = b.type, e = b.pendingProps, f = null !== a ? a.memoizedProps : null, g = e.children, nf(d, e) ? g = null : null !== f && nf(d, f) && (b.flags |= 16), oi(a, b), fi(a, b, g, c), b.child;
        case 6:
            return null === a && ph(b), null;
        case 13:
            return ti(a, b, c);
        case 4:
            return eh(b, b.stateNode.containerInfo), d = b.pendingProps, null === a ? b.child = Yg(b, null, d, c) : fi(a, b, d, c), b.child;
        case 11:
            return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : lg(d, e), gi(a, b, d, e, c);
        case 7:
            return fi(a, b, b.pendingProps, c), b.child;
        case 8:
            return fi(a, b, b.pendingProps.children,
                c), b.child;
        case 12:
            return fi(a, b, b.pendingProps.children, c), b.child;
        case 10:
            a: {
                d = b.type._context;
                e = b.pendingProps;
                g = b.memoizedProps;
                f = e.value;
                var h = b.type._context;
                I(mg, h._currentValue);
                h._currentValue = f;
                if (null !== g)
                    if (h = g.value, f = He(h, f) ? 0 : ("function" === typeof d._calculateChangedBits ? d._calculateChangedBits(h, f) : 1073741823) | 0, 0 === f) {
                        if (g.children === e.children && !N.current) {
                            b = hi(a, b, c);
                            break a
                        }
                    } else
                        for (h = b.child, null !== h && (h.return = b); null !== h;) {
                            var k = h.dependencies;
                            if (null !== k) {
                                g = h.child;
                                for (var l =
                                        k.firstContext; null !== l;) {
                                    if (l.context === d && 0 !== (l.observedBits & f)) {
                                        1 === h.tag && (l = zg(-1, c & -c), l.tag = 2, Ag(h, l));
                                        h.lanes |= c;
                                        l = h.alternate;
                                        null !== l && (l.lanes |= c);
                                        sg(h.return, c);
                                        k.lanes |= c;
                                        break
                                    }
                                    l = l.next
                                }
                            } else g = 10 === h.tag ? h.type === b.type ? null : h.child : h.child;
                            if (null !== g) g.return = h;
                            else
                                for (g = h; null !== g;) {
                                    if (g === b) {
                                        g = null;
                                        break
                                    }
                                    h = g.sibling;
                                    if (null !== h) {
                                        h.return = g.return;
                                        g = h;
                                        break
                                    }
                                    g = g.return
                                }
                            h = g
                        }
                    fi(a, b, e.children, c);
                b = b.child
            }
            return b;
        case 9:
            return e = b.type, f = b.pendingProps, d = f.children, tg(b, c), e = vg(e,
                f.unstable_observedBits), d = d(e), b.flags |= 1, fi(a, b, d, c), b.child;
        case 14:
            return e = b.type, f = lg(e, b.pendingProps), f = lg(e.type, f), ii(a, b, e, f, d, c);
        case 15:
            return ki(a, b, b.type, b.pendingProps, d, c);
        case 17:
            return d = b.type, e = b.pendingProps, e = b.elementType === d ? e : lg(d, e), null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2), b.tag = 1, Ff(d) ? (a = !0, Jf(b)) : a = !1, tg(b, c), Mg(b, d, e), Og(b, d, e, c), qi(null, b, d, !0, a, c);
        case 19:
            return Ai(a, b, c);
        case 23:
            return mi(a, b, c);
        case 24:
            return mi(a, b, c)
    }
    throw Error(y(156, b.tag));
};

function ik(a, b, c, d) {
    this.tag = a;
    this.key = c;
    this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
    this.index = 0;
    this.ref = null;
    this.pendingProps = b;
    this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
    this.mode = d;
    this.flags = 0;
    this.lastEffect = this.firstEffect = this.nextEffect = null;
    this.childLanes = this.lanes = 0;
    this.alternate = null
}

function nh(a, b, c, d) {
    return new ik(a, b, c, d)
}

function ji(a) {
    a = a.prototype;
    return !(!a || !a.isReactComponent)
}

function hk(a) {
    if ("function" === typeof a) return ji(a) ? 1 : 0;
    if (void 0 !== a && null !== a) {
        a = a.$$typeof;
        if (a === Aa) return 11;
        if (a === Da) return 14
    }
    return 2
}

function Tg(a, b) {
    var c = a.alternate;
    null === c ? (c = nh(a.tag, b, a.key, a.mode), c.elementType = a.elementType, c.type = a.type, c.stateNode = a.stateNode, c.alternate = a, a.alternate = c) : (c.pendingProps = b, c.type = a.type, c.flags = 0, c.nextEffect = null, c.firstEffect = null, c.lastEffect = null);
    c.childLanes = a.childLanes;
    c.lanes = a.lanes;
    c.child = a.child;
    c.memoizedProps = a.memoizedProps;
    c.memoizedState = a.memoizedState;
    c.updateQueue = a.updateQueue;
    b = a.dependencies;
    c.dependencies = null === b ? null : {
        lanes: b.lanes,
        firstContext: b.firstContext
    };
    c.sibling = a.sibling;
    c.index = a.index;
    c.ref = a.ref;
    return c
}

function Vg(a, b, c, d, e, f) {
    var g = 2;
    d = a;
    if ("function" === typeof a) ji(a) && (g = 1);
    else if ("string" === typeof a) g = 5;
    else a: switch (a) {
        case ua:
            return Xg(c.children, e, f, b);
        case Ha:
            g = 8;
            e |= 16;
            break;
        case wa:
            g = 8;
            e |= 1;
            break;
        case xa:
            return a = nh(12, c, b, e | 8), a.elementType = xa, a.type = xa, a.lanes = f, a;
        case Ba:
            return a = nh(13, c, b, e), a.type = Ba, a.elementType = Ba, a.lanes = f, a;
        case Ca:
            return a = nh(19, c, b, e), a.elementType = Ca, a.lanes = f, a;
        case Ia:
            return vi(c, e, f, b);
        case Ja:
            return a = nh(24, c, b, e), a.elementType = Ja, a.lanes = f, a;
        default:
            if ("object" ===
                typeof a && null !== a) switch (a.$$typeof) {
                case ya:
                    g = 10;
                    break a;
                case za:
                    g = 9;
                    break a;
                case Aa:
                    g = 11;
                    break a;
                case Da:
                    g = 14;
                    break a;
                case Ea:
                    g = 16;
                    d = null;
                    break a;
                case Fa:
                    g = 22;
                    break a
            }
            throw Error(y(130, null == a ? a : typeof a, ""));
    }
    b = nh(g, c, b, e);
    b.elementType = a;
    b.type = d;
    b.lanes = f;
    return b
}

function Xg(a, b, c, d) {
    a = nh(7, a, d, b);
    a.lanes = c;
    return a
}

function vi(a, b, c, d) {
    a = nh(23, a, d, b);
    a.elementType = Ia;
    a.lanes = c;
    return a
}

function Ug(a, b, c) {
    a = nh(6, a, null, b);
    a.lanes = c;
    return a
}

function Wg(a, b, c) {
    b = nh(4, null !== a.children ? a.children : [], a.key, b);
    b.lanes = c;
    b.stateNode = {
        containerInfo: a.containerInfo,
        pendingChildren: null,
        implementation: a.implementation
    };
    return b
}

function jk(a, b, c) {
    this.tag = b;
    this.containerInfo = a;
    this.finishedWork = this.pingCache = this.current = this.pendingChildren = null;
    this.timeoutHandle = -1;
    this.pendingContext = this.context = null;
    this.hydrate = c;
    this.callbackNode = null;
    this.callbackPriority = 0;
    this.eventTimes = Zc(0);
    this.expirationTimes = Zc(-1);
    this.entangledLanes = this.finishedLanes = this.mutableReadLanes = this.expiredLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
    this.entanglements = Zc(0);
    this.mutableSourceEagerHydrationData = null
}

function kk(a, b, c) {
    var d = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
    return {
        $$typeof: ta,
        key: null == d ? null : "" + d,
        children: a,
        containerInfo: b,
        implementation: c
    }
}

function lk(a, b, c, d) {
    var e = b.current,
        f = Hg(),
        g = Ig(e);
    a: if (c) {
        c = c._reactInternals;
        b: {
            if (Zb(c) !== c || 1 !== c.tag) throw Error(y(170));
            var h = c;
            do {
                switch (h.tag) {
                    case 3:
                        h = h.stateNode.context;
                        break b;
                    case 1:
                        if (Ff(h.type)) {
                            h = h.stateNode.__reactInternalMemoizedMergedChildContext;
                            break b
                        }
                }
                h = h.return
            } while (null !== h);
            throw Error(y(171));
        }
        if (1 === c.tag) {
            var k = c.type;
            if (Ff(k)) {
                c = If(c, k, h);
                break a
            }
        }
        c = h
    } else c = Cf;
    null === b.context ? b.context = c : b.pendingContext = c;
    b = zg(f, g);
    b.payload = {
        element: a
    };
    d = void 0 === d ? null : d;
    null !==
        d && (b.callback = d);
    Ag(e, b);
    Jg(e, g, f);
    return g
}

function mk(a) {
    a = a.current;
    if (!a.child) return null;
    switch (a.child.tag) {
        case 5:
            return a.child.stateNode;
        default:
            return a.child.stateNode
    }
}

function nk(a, b) {
    a = a.memoizedState;
    if (null !== a && null !== a.dehydrated) {
        var c = a.retryLane;
        a.retryLane = 0 !== c && c < b ? c : b
    }
}

function ok(a, b) {
    nk(a, b);
    (a = a.alternate) && nk(a, b)
}

function pk() {
    return null
}

function qk(a, b, c) {
    var d = null != c && null != c.hydrationOptions && c.hydrationOptions.mutableSources || null;
    c = new jk(a, b, null != c && !0 === c.hydrate);
    b = nh(3, null, null, 2 === b ? 7 : 1 === b ? 3 : 0);
    c.current = b;
    b.stateNode = c;
    xg(b);
    a[ff] = c.current;
    cf(8 === a.nodeType ? a.parentNode : a);
    if (d)
        for (a = 0; a < d.length; a++) {
            b = d[a];
            var e = b._getVersion;
            e = e(b._source);
            null == c.mutableSourceEagerHydrationData ? c.mutableSourceEagerHydrationData = [b, e] : c.mutableSourceEagerHydrationData.push(b, e)
        }
    this._internalRoot = c
}
qk.prototype.render = function(a) {
    lk(a, this._internalRoot, null, null)
};
qk.prototype.unmount = function() {
    var a = this._internalRoot,
        b = a.containerInfo;
    lk(null, a, null, function() {
        b[ff] = null
    })
};

function rk(a) {
    return !(!a || 1 !== a.nodeType && 9 !== a.nodeType && 11 !== a.nodeType && (8 !== a.nodeType || " react-mount-point-unstable " !== a.nodeValue))
}

function sk(a, b) {
    b || (b = a ? 9 === a.nodeType ? a.documentElement : a.firstChild : null, b = !(!b || 1 !== b.nodeType || !b.hasAttribute("data-reactroot")));
    if (!b)
        for (var c; c = a.lastChild;) a.removeChild(c);
    return new qk(a, 0, b ? {
        hydrate: !0
    } : void 0)
}

function tk(a, b, c, d, e) {
    var f = c._reactRootContainer;
    if (f) {
        var g = f._internalRoot;
        if ("function" === typeof e) {
            var h = e;
            e = function() {
                var a = mk(g);
                h.call(a)
            }
        }
        lk(b, g, a, e)
    } else {
        f = c._reactRootContainer = sk(c, d);
        g = f._internalRoot;
        if ("function" === typeof e) {
            var k = e;
            e = function() {
                var a = mk(g);
                k.call(a)
            }
        }
        Xj(function() {
            lk(b, g, a, e)
        })
    }
    return mk(g)
}
ec = function(a) {
    if (13 === a.tag) {
        var b = Hg();
        Jg(a, 4, b);
        ok(a, 4)
    }
};
fc = function(a) {
    if (13 === a.tag) {
        var b = Hg();
        Jg(a, 67108864, b);
        ok(a, 67108864)
    }
};
gc = function(a) {
    if (13 === a.tag) {
        var b = Hg(),
            c = Ig(a);
        Jg(a, c, b);
        ok(a, c)
    }
};
hc = function(a, b) {
    return b()
};
yb = function(a, b, c) {
    switch (b) {
        case "input":
            ab(a, c);
            b = c.name;
            if ("radio" === c.type && null != b) {
                for (c = a; c.parentNode;) c = c.parentNode;
                c = c.querySelectorAll("input[name=" + JSON.stringify("" + b) + '][type="radio"]');
                for (b = 0; b < c.length; b++) {
                    var d = c[b];
                    if (d !== a && d.form === a.form) {
                        var e = Db(d);
                        if (!e) throw Error(y(90));
                        Wa(d);
                        ab(d, e)
                    }
                }
            }
            break;
        case "textarea":
            ib(a, c);
            break;
        case "select":
            b = c.value, null != b && fb(a, !!c.multiple, b, !1)
    }
};
Gb = Wj;
Hb = function(a, b, c, d, e) {
    var f = X;
    X |= 4;
    try {
        return gg(98, a.bind(null, b, c, d, e))
    } finally {
        X = f, 0 === X && (wj(), ig())
    }
};
Ib = function() {
    0 === (X & 49) && (Vj(), Oj())
};
Jb = function(a, b) {
    var c = X;
    X |= 2;
    try {
        return a(b)
    } finally {
        X = c, 0 === X && (wj(), ig())
    }
};

function uk(a, b) {
    var c = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
    if (!rk(b)) throw Error(y(200));
    return kk(a, b, null, c)
}
var vk = {
        Events: [Cb, ue, Db, Eb, Fb, Oj, {
            current: !1
        }]
    },
    wk = {
        findFiberByHostInstance: wc,
        bundleType: 0,
        version: "17.0.1",
        rendererPackageName: "react-dom"
    };
var xk = {
    bundleType: wk.bundleType,
    version: wk.version,
    rendererPackageName: wk.rendererPackageName,
    rendererConfig: wk.rendererConfig,
    overrideHookState: null,
    overrideHookStateDeletePath: null,
    overrideHookStateRenamePath: null,
    overrideProps: null,
    overridePropsDeletePath: null,
    overridePropsRenamePath: null,
    setSuspenseHandler: null,
    scheduleUpdate: null,
    currentDispatcherRef: ra.ReactCurrentDispatcher,
    findHostInstanceByFiber: function(a) {
        a = cc(a);
        return null === a ? null : a.stateNode
    },
    findFiberByHostInstance: wk.findFiberByHostInstance ||
        pk,
    findHostInstancesForRefresh: null,
    scheduleRefresh: null,
    scheduleRoot: null,
    setRefreshHandler: null,
    getCurrentFiber: null
};
if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
    var yk = __REACT_DEVTOOLS_GLOBAL_HOOK__;
    if (!yk.isDisabled && yk.supportsFiber) try {
        Lf = yk.inject(xk), Mf = yk
    } catch (a) {}
}
exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = vk;
exports.createPortal = uk;
exports.findDOMNode = function(a) {
    if (null == a) return null;
    if (1 === a.nodeType) return a;
    var b = a._reactInternals;
    if (void 0 === b) {
        if ("function" === typeof a.render) throw Error(y(188));
        throw Error(y(268, Object.keys(a)));
    }
    a = cc(b);
    a = null === a ? null : a.stateNode;
    return a
};
exports.flushSync = function(a, b) {
    var c = X;
    if (0 !== (c & 48)) return a(b);
    X |= 1;
    try {
        if (a) return gg(99, a.bind(null, b))
    } finally {
        X = c, ig()
    }
};
exports.hydrate = function(a, b, c) {
    if (!rk(b)) throw Error(y(200));
    return tk(null, a, b, !0, c)
};
exports.render = function(a, b, c) {
    if (!rk(b)) throw Error(y(200));
    return tk(null, a, b, !1, c)
};
exports.unmountComponentAtNode = function(a) {
    if (!rk(a)) throw Error(y(40));
    return a._reactRootContainer ? (Xj(function() {
        tk(null, null, a, !1, function() {
            a._reactRootContainer = null;
            a[ff] = null
        })
    }), !0) : !1
};
exports.unstable_batchedUpdates = Wj;
exports.unstable_createPortal = function(a, b) {
    return uk(a, b, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null)
};
exports.unstable_renderSubtreeIntoContainer = function(a, b, c, d) {
    if (!rk(c)) throw Error(y(200));
    if (null == a || void 0 === a._reactInternals) throw Error(y(38));
    return tk(a, b, c, !1, d)
};
exports.version = "17.0.1";
//# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://aem-cms-code/./node_modules/react-dom/cjs/react-dom.production.min.js?ca5d"],"names":[],"mappings":"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","file":"4448.js","sourcesContent":["/** @license React v17.0.1\n * react-dom.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n/*\n Modernizr 3.0.0pre (Custom Build) | MIT\n*/\n'use strict';var aa=require(\"react\"),m=require(\"object-assign\"),r=require(\"scheduler\");function y(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}if(!aa)throw Error(y(227));var ba=new Set,ca={};function da(a,b){ea(a,b);ea(a+\"Capture\",b)}\nfunction ea(a,b){ca[a]=b;for(a=0;a<b.length;a++)ba.add(b[a])}\nvar fa=!(\"undefined\"===typeof window||\"undefined\"===typeof window.document||\"undefined\"===typeof window.document.createElement),ha=/^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$/,ia=Object.prototype.hasOwnProperty,\nja={},ka={};function la(a){if(ia.call(ka,a))return!0;if(ia.call(ja,a))return!1;if(ha.test(a))return ka[a]=!0;ja[a]=!0;return!1}function ma(a,b,c,d){if(null!==c&&0===c.type)return!1;switch(typeof b){case \"function\":case \"symbol\":return!0;case \"boolean\":if(d)return!1;if(null!==c)return!c.acceptsBooleans;a=a.toLowerCase().slice(0,5);return\"data-\"!==a&&\"aria-\"!==a;default:return!1}}\nfunction na(a,b,c,d){if(null===b||\"undefined\"===typeof b||ma(a,b,c,d))return!0;if(d)return!1;if(null!==c)switch(c.type){case 3:return!b;case 4:return!1===b;case 5:return isNaN(b);case 6:return isNaN(b)||1>b}return!1}function B(a,b,c,d,e,f,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g}var D={};\n\"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style\".split(\" \").forEach(function(a){D[a]=new B(a,0,!1,a,null,!1,!1)});[[\"acceptCharset\",\"accept-charset\"],[\"className\",\"class\"],[\"htmlFor\",\"for\"],[\"httpEquiv\",\"http-equiv\"]].forEach(function(a){var b=a[0];D[b]=new B(b,1,!1,a[1],null,!1,!1)});[\"contentEditable\",\"draggable\",\"spellCheck\",\"value\"].forEach(function(a){D[a]=new B(a,2,!1,a.toLowerCase(),null,!1,!1)});\n[\"autoReverse\",\"externalResourcesRequired\",\"focusable\",\"preserveAlpha\"].forEach(function(a){D[a]=new B(a,2,!1,a,null,!1,!1)});\"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope\".split(\" \").forEach(function(a){D[a]=new B(a,3,!1,a.toLowerCase(),null,!1,!1)});\n[\"checked\",\"multiple\",\"muted\",\"selected\"].forEach(function(a){D[a]=new B(a,3,!0,a,null,!1,!1)});[\"capture\",\"download\"].forEach(function(a){D[a]=new B(a,4,!1,a,null,!1,!1)});[\"cols\",\"rows\",\"size\",\"span\"].forEach(function(a){D[a]=new B(a,6,!1,a,null,!1,!1)});[\"rowSpan\",\"start\"].forEach(function(a){D[a]=new B(a,5,!1,a.toLowerCase(),null,!1,!1)});var oa=/[\\-:]([a-z])/g;function pa(a){return a[1].toUpperCase()}\n\"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height\".split(\" \").forEach(function(a){var b=a.replace(oa,\npa);D[b]=new B(b,1,!1,a,null,!1,!1)});\"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type\".split(\" \").forEach(function(a){var b=a.replace(oa,pa);D[b]=new B(b,1,!1,a,\"http://www.w3.org/1999/xlink\",!1,!1)});[\"xml:base\",\"xml:lang\",\"xml:space\"].forEach(function(a){var b=a.replace(oa,pa);D[b]=new B(b,1,!1,a,\"http://www.w3.org/XML/1998/namespace\",!1,!1)});[\"tabIndex\",\"crossOrigin\"].forEach(function(a){D[a]=new B(a,1,!1,a.toLowerCase(),null,!1,!1)});\nD.xlinkHref=new B(\"xlinkHref\",1,!1,\"xlink:href\",\"http://www.w3.org/1999/xlink\",!0,!1);[\"src\",\"href\",\"action\",\"formAction\"].forEach(function(a){D[a]=new B(a,1,!1,a.toLowerCase(),null,!0,!0)});\nfunction qa(a,b,c,d){var e=D.hasOwnProperty(b)?D[b]:null;var f=null!==e?0===e.type:d?!1:!(2<b.length)||\"o\"!==b[0]&&\"O\"!==b[0]||\"n\"!==b[1]&&\"N\"!==b[1]?!1:!0;f||(na(b,c,e,d)&&(c=null),d||null===e?la(b)&&(null===c?a.removeAttribute(b):a.setAttribute(b,\"\"+c)):e.mustUseProperty?a[e.propertyName]=null===c?3===e.type?!1:\"\":c:(b=e.attributeName,d=e.attributeNamespace,null===c?a.removeAttribute(b):(e=e.type,c=3===e||4===e&&!0===c?\"\":\"\"+c,d?a.setAttributeNS(d,b,c):a.setAttribute(b,c))))}\nvar ra=aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,sa=60103,ta=60106,ua=60107,wa=60108,xa=60114,ya=60109,za=60110,Aa=60112,Ba=60113,Ca=60120,Da=60115,Ea=60116,Fa=60121,Ga=60128,Ha=60129,Ia=60130,Ja=60131;\nif(\"function\"===typeof Symbol&&Symbol.for){var E=Symbol.for;sa=E(\"react.element\");ta=E(\"react.portal\");ua=E(\"react.fragment\");wa=E(\"react.strict_mode\");xa=E(\"react.profiler\");ya=E(\"react.provider\");za=E(\"react.context\");Aa=E(\"react.forward_ref\");Ba=E(\"react.suspense\");Ca=E(\"react.suspense_list\");Da=E(\"react.memo\");Ea=E(\"react.lazy\");Fa=E(\"react.block\");E(\"react.scope\");Ga=E(\"react.opaque.id\");Ha=E(\"react.debug_trace_mode\");Ia=E(\"react.offscreen\");Ja=E(\"react.legacy_hidden\")}\nvar Ka=\"function\"===typeof Symbol&&Symbol.iterator;function La(a){if(null===a||\"object\"!==typeof a)return null;a=Ka&&a[Ka]||a[\"@@iterator\"];return\"function\"===typeof a?a:null}var Ma;function Na(a){if(void 0===Ma)try{throw Error();}catch(c){var b=c.stack.trim().match(/\\n( *(at )?)/);Ma=b&&b[1]||\"\"}return\"\\n\"+Ma+a}var Oa=!1;\nfunction Pa(a,b){if(!a||Oa)return\"\";Oa=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,\"props\",{set:function(){throw Error();}}),\"object\"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[])}catch(k){var d=k}Reflect.construct(a,[],b)}else{try{b.call()}catch(k){d=k}a.call(b.prototype)}else{try{throw Error();}catch(k){d=k}a()}}catch(k){if(k&&d&&\"string\"===typeof k.stack){for(var e=k.stack.split(\"\\n\"),\nf=d.stack.split(\"\\n\"),g=e.length-1,h=f.length-1;1<=g&&0<=h&&e[g]!==f[h];)h--;for(;1<=g&&0<=h;g--,h--)if(e[g]!==f[h]){if(1!==g||1!==h){do if(g--,h--,0>h||e[g]!==f[h])return\"\\n\"+e[g].replace(\" at new \",\" at \");while(1<=g&&0<=h)}break}}}finally{Oa=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:\"\")?Na(a):\"\"}\nfunction Qa(a){switch(a.tag){case 5:return Na(a.type);case 16:return Na(\"Lazy\");case 13:return Na(\"Suspense\");case 19:return Na(\"SuspenseList\");case 0:case 2:case 15:return a=Pa(a.type,!1),a;case 11:return a=Pa(a.type.render,!1),a;case 22:return a=Pa(a.type._render,!1),a;case 1:return a=Pa(a.type,!0),a;default:return\"\"}}\nfunction Ra(a){if(null==a)return null;if(\"function\"===typeof a)return a.displayName||a.name||null;if(\"string\"===typeof a)return a;switch(a){case ua:return\"Fragment\";case ta:return\"Portal\";case xa:return\"Profiler\";case wa:return\"StrictMode\";case Ba:return\"Suspense\";case Ca:return\"SuspenseList\"}if(\"object\"===typeof a)switch(a.$$typeof){case za:return(a.displayName||\"Context\")+\".Consumer\";case ya:return(a._context.displayName||\"Context\")+\".Provider\";case Aa:var b=a.render;b=b.displayName||b.name||\"\";\nreturn a.displayName||(\"\"!==b?\"ForwardRef(\"+b+\")\":\"ForwardRef\");case Da:return Ra(a.type);case Fa:return Ra(a._render);case Ea:b=a._payload;a=a._init;try{return Ra(a(b))}catch(c){}}return null}function Sa(a){switch(typeof a){case \"boolean\":case \"number\":case \"object\":case \"string\":case \"undefined\":return a;default:return\"\"}}function Ta(a){var b=a.type;return(a=a.nodeName)&&\"input\"===a.toLowerCase()&&(\"checkbox\"===b||\"radio\"===b)}\nfunction Ua(a){var b=Ta(a)?\"checked\":\"value\",c=Object.getOwnPropertyDescriptor(a.constructor.prototype,b),d=\"\"+a[b];if(!a.hasOwnProperty(b)&&\"undefined\"!==typeof c&&\"function\"===typeof c.get&&\"function\"===typeof c.set){var e=c.get,f=c.set;Object.defineProperty(a,b,{configurable:!0,get:function(){return e.call(this)},set:function(a){d=\"\"+a;f.call(this,a)}});Object.defineProperty(a,b,{enumerable:c.enumerable});return{getValue:function(){return d},setValue:function(a){d=\"\"+a},stopTracking:function(){a._valueTracker=\nnull;delete a[b]}}}}function Va(a){a._valueTracker||(a._valueTracker=Ua(a))}function Wa(a){if(!a)return!1;var b=a._valueTracker;if(!b)return!0;var c=b.getValue();var d=\"\";a&&(d=Ta(a)?a.checked?\"true\":\"false\":a.value);a=d;return a!==c?(b.setValue(a),!0):!1}function Xa(a){a=a||(\"undefined\"!==typeof document?document:void 0);if(\"undefined\"===typeof a)return null;try{return a.activeElement||a.body}catch(b){return a.body}}\nfunction Ya(a,b){var c=b.checked;return m({},b,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:null!=c?c:a._wrapperState.initialChecked})}function Za(a,b){var c=null==b.defaultValue?\"\":b.defaultValue,d=null!=b.checked?b.checked:b.defaultChecked;c=Sa(null!=b.value?b.value:c);a._wrapperState={initialChecked:d,initialValue:c,controlled:\"checkbox\"===b.type||\"radio\"===b.type?null!=b.checked:null!=b.value}}function $a(a,b){b=b.checked;null!=b&&qa(a,\"checked\",b,!1)}\nfunction ab(a,b){$a(a,b);var c=Sa(b.value),d=b.type;if(null!=c)if(\"number\"===d){if(0===c&&\"\"===a.value||a.value!=c)a.value=\"\"+c}else a.value!==\"\"+c&&(a.value=\"\"+c);else if(\"submit\"===d||\"reset\"===d){a.removeAttribute(\"value\");return}b.hasOwnProperty(\"value\")?bb(a,b.type,c):b.hasOwnProperty(\"defaultValue\")&&bb(a,b.type,Sa(b.defaultValue));null==b.checked&&null!=b.defaultChecked&&(a.defaultChecked=!!b.defaultChecked)}\nfunction cb(a,b,c){if(b.hasOwnProperty(\"value\")||b.hasOwnProperty(\"defaultValue\")){var d=b.type;if(!(\"submit\"!==d&&\"reset\"!==d||void 0!==b.value&&null!==b.value))return;b=\"\"+a._wrapperState.initialValue;c||b===a.value||(a.value=b);a.defaultValue=b}c=a.name;\"\"!==c&&(a.name=\"\");a.defaultChecked=!!a._wrapperState.initialChecked;\"\"!==c&&(a.name=c)}\nfunction bb(a,b,c){if(\"number\"!==b||Xa(a.ownerDocument)!==a)null==c?a.defaultValue=\"\"+a._wrapperState.initialValue:a.defaultValue!==\"\"+c&&(a.defaultValue=\"\"+c)}function db(a){var b=\"\";aa.Children.forEach(a,function(a){null!=a&&(b+=a)});return b}function eb(a,b){a=m({children:void 0},b);if(b=db(b.children))a.children=b;return a}\nfunction fb(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b[\"$\"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty(\"$\"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0)}else{c=\"\"+Sa(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e])}null!==b&&(b.selected=!0)}}\nfunction gb(a,b){if(null!=b.dangerouslySetInnerHTML)throw Error(y(91));return m({},b,{value:void 0,defaultValue:void 0,children:\"\"+a._wrapperState.initialValue})}function hb(a,b){var c=b.value;if(null==c){c=b.children;b=b.defaultValue;if(null!=c){if(null!=b)throw Error(y(92));if(Array.isArray(c)){if(!(1>=c.length))throw Error(y(93));c=c[0]}b=c}null==b&&(b=\"\");c=b}a._wrapperState={initialValue:Sa(c)}}\nfunction ib(a,b){var c=Sa(b.value),d=Sa(b.defaultValue);null!=c&&(c=\"\"+c,c!==a.value&&(a.value=c),null==b.defaultValue&&a.defaultValue!==c&&(a.defaultValue=c));null!=d&&(a.defaultValue=\"\"+d)}function jb(a){var b=a.textContent;b===a._wrapperState.initialValue&&\"\"!==b&&null!==b&&(a.value=b)}var kb={html:\"http://www.w3.org/1999/xhtml\",mathml:\"http://www.w3.org/1998/Math/MathML\",svg:\"http://www.w3.org/2000/svg\"};\nfunction lb(a){switch(a){case \"svg\":return\"http://www.w3.org/2000/svg\";case \"math\":return\"http://www.w3.org/1998/Math/MathML\";default:return\"http://www.w3.org/1999/xhtml\"}}function mb(a,b){return null==a||\"http://www.w3.org/1999/xhtml\"===a?lb(b):\"http://www.w3.org/2000/svg\"===a&&\"foreignObject\"===b?\"http://www.w3.org/1999/xhtml\":a}\nvar nb,ob=function(a){return\"undefined\"!==typeof MSApp&&MSApp.execUnsafeLocalFunction?function(b,c,d,e){MSApp.execUnsafeLocalFunction(function(){return a(b,c,d,e)})}:a}(function(a,b){if(a.namespaceURI!==kb.svg||\"innerHTML\"in a)a.innerHTML=b;else{nb=nb||document.createElement(\"div\");nb.innerHTML=\"<svg>\"+b.valueOf().toString()+\"</svg>\";for(b=nb.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChild;)a.appendChild(b.firstChild)}});\nfunction pb(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b}\nvar qb={animationIterationCount:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,\nfloodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},rb=[\"Webkit\",\"ms\",\"Moz\",\"O\"];Object.keys(qb).forEach(function(a){rb.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);qb[b]=qb[a]})});function sb(a,b,c){return null==b||\"boolean\"===typeof b||\"\"===b?\"\":c||\"number\"!==typeof b||0===b||qb.hasOwnProperty(a)&&qb[a]?(\"\"+b).trim():b+\"px\"}\nfunction tb(a,b){a=a.style;for(var c in b)if(b.hasOwnProperty(c)){var d=0===c.indexOf(\"--\"),e=sb(c,b[c],d);\"float\"===c&&(c=\"cssFloat\");d?a.setProperty(c,e):a[c]=e}}var ub=m({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});\nfunction vb(a,b){if(b){if(ub[a]&&(null!=b.children||null!=b.dangerouslySetInnerHTML))throw Error(y(137,a));if(null!=b.dangerouslySetInnerHTML){if(null!=b.children)throw Error(y(60));if(!(\"object\"===typeof b.dangerouslySetInnerHTML&&\"__html\"in b.dangerouslySetInnerHTML))throw Error(y(61));}if(null!=b.style&&\"object\"!==typeof b.style)throw Error(y(62));}}\nfunction wb(a,b){if(-1===a.indexOf(\"-\"))return\"string\"===typeof b.is;switch(a){case \"annotation-xml\":case \"color-profile\":case \"font-face\":case \"font-face-src\":case \"font-face-uri\":case \"font-face-format\":case \"font-face-name\":case \"missing-glyph\":return!1;default:return!0}}function xb(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var yb=null,zb=null,Ab=null;\nfunction Bb(a){if(a=Cb(a)){if(\"function\"!==typeof yb)throw Error(y(280));var b=a.stateNode;b&&(b=Db(b),yb(a.stateNode,a.type,b))}}function Eb(a){zb?Ab?Ab.push(a):Ab=[a]:zb=a}function Fb(){if(zb){var a=zb,b=Ab;Ab=zb=null;Bb(a);if(b)for(a=0;a<b.length;a++)Bb(b[a])}}function Gb(a,b){return a(b)}function Hb(a,b,c,d,e){return a(b,c,d,e)}function Ib(){}var Jb=Gb,Kb=!1,Lb=!1;function Mb(){if(null!==zb||null!==Ab)Ib(),Fb()}\nfunction Nb(a,b,c){if(Lb)return a(b,c);Lb=!0;try{return Jb(a,b,c)}finally{Lb=!1,Mb()}}\nfunction Ob(a,b){var c=a.stateNode;if(null===c)return null;var d=Db(c);if(null===d)return null;c=d[b];a:switch(b){case \"onClick\":case \"onClickCapture\":case \"onDoubleClick\":case \"onDoubleClickCapture\":case \"onMouseDown\":case \"onMouseDownCapture\":case \"onMouseMove\":case \"onMouseMoveCapture\":case \"onMouseUp\":case \"onMouseUpCapture\":case \"onMouseEnter\":(d=!d.disabled)||(a=a.type,d=!(\"button\"===a||\"input\"===a||\"select\"===a||\"textarea\"===a));a=!d;break a;default:a=!1}if(a)return null;if(c&&\"function\"!==\ntypeof c)throw Error(y(231,b,typeof c));return c}var Pb=!1;if(fa)try{var Qb={};Object.defineProperty(Qb,\"passive\",{get:function(){Pb=!0}});window.addEventListener(\"test\",Qb,Qb);window.removeEventListener(\"test\",Qb,Qb)}catch(a){Pb=!1}function Rb(a,b,c,d,e,f,g,h,k){var l=Array.prototype.slice.call(arguments,3);try{b.apply(c,l)}catch(n){this.onError(n)}}var Sb=!1,Tb=null,Ub=!1,Vb=null,Wb={onError:function(a){Sb=!0;Tb=a}};function Xb(a,b,c,d,e,f,g,h,k){Sb=!1;Tb=null;Rb.apply(Wb,arguments)}\nfunction Yb(a,b,c,d,e,f,g,h,k){Xb.apply(this,arguments);if(Sb){if(Sb){var l=Tb;Sb=!1;Tb=null}else throw Error(y(198));Ub||(Ub=!0,Vb=l)}}function Zb(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else{a=b;do b=a,0!==(b.flags&1026)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}function $b(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function ac(a){if(Zb(a)!==a)throw Error(y(188));}\nfunction bc(a){var b=a.alternate;if(!b){b=Zb(a);if(null===b)throw Error(y(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return ac(e),a;if(f===d)return ac(e),b;f=f.sibling}throw Error(y(188));}if(c.return!==d.return)c=e,d=f;else{for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling}if(!g){for(h=f.child;h;){if(h===\nc){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling}if(!g)throw Error(y(189));}}if(c.alternate!==d)throw Error(y(190));}if(3!==c.tag)throw Error(y(188));return c.stateNode.current===c?a:b}function cc(a){a=bc(a);if(!a)return null;for(var b=a;;){if(5===b.tag||6===b.tag)return b;if(b.child)b.child.return=b,b=b.child;else{if(b===a)break;for(;!b.sibling;){if(!b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}}return null}\nfunction dc(a,b){for(var c=a.alternate;null!==b;){if(b===a||b===c)return!0;b=b.return}return!1}var ec,fc,gc,hc,ic=!1,jc=[],kc=null,lc=null,mc=null,nc=new Map,oc=new Map,pc=[],qc=\"mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit\".split(\" \");\nfunction rc(a,b,c,d,e){return{blockedOn:a,domEventName:b,eventSystemFlags:c|16,nativeEvent:e,targetContainers:[d]}}function sc(a,b){switch(a){case \"focusin\":case \"focusout\":kc=null;break;case \"dragenter\":case \"dragleave\":lc=null;break;case \"mouseover\":case \"mouseout\":mc=null;break;case \"pointerover\":case \"pointerout\":nc.delete(b.pointerId);break;case \"gotpointercapture\":case \"lostpointercapture\":oc.delete(b.pointerId)}}\nfunction tc(a,b,c,d,e,f){if(null===a||a.nativeEvent!==f)return a=rc(b,c,d,e,f),null!==b&&(b=Cb(b),null!==b&&fc(b)),a;a.eventSystemFlags|=d;b=a.targetContainers;null!==e&&-1===b.indexOf(e)&&b.push(e);return a}\nfunction uc(a,b,c,d,e){switch(b){case \"focusin\":return kc=tc(kc,a,b,c,d,e),!0;case \"dragenter\":return lc=tc(lc,a,b,c,d,e),!0;case \"mouseover\":return mc=tc(mc,a,b,c,d,e),!0;case \"pointerover\":var f=e.pointerId;nc.set(f,tc(nc.get(f)||null,a,b,c,d,e));return!0;case \"gotpointercapture\":return f=e.pointerId,oc.set(f,tc(oc.get(f)||null,a,b,c,d,e)),!0}return!1}\nfunction vc(a){var b=wc(a.target);if(null!==b){var c=Zb(b);if(null!==c)if(b=c.tag,13===b){if(b=$b(c),null!==b){a.blockedOn=b;hc(a.lanePriority,function(){r.unstable_runWithPriority(a.priority,function(){gc(c)})});return}}else if(3===b&&c.stateNode.hydrate){a.blockedOn=3===c.tag?c.stateNode.containerInfo:null;return}}a.blockedOn=null}\nfunction xc(a){if(null!==a.blockedOn)return!1;for(var b=a.targetContainers;0<b.length;){var c=yc(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null!==c)return b=Cb(c),null!==b&&fc(b),a.blockedOn=c,!1;b.shift()}return!0}function zc(a,b,c){xc(a)&&c.delete(b)}\nfunction Ac(){for(ic=!1;0<jc.length;){var a=jc[0];if(null!==a.blockedOn){a=Cb(a.blockedOn);null!==a&&ec(a);break}for(var b=a.targetContainers;0<b.length;){var c=yc(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null!==c){a.blockedOn=c;break}b.shift()}null===a.blockedOn&&jc.shift()}null!==kc&&xc(kc)&&(kc=null);null!==lc&&xc(lc)&&(lc=null);null!==mc&&xc(mc)&&(mc=null);nc.forEach(zc);oc.forEach(zc)}\nfunction Bc(a,b){a.blockedOn===b&&(a.blockedOn=null,ic||(ic=!0,r.unstable_scheduleCallback(r.unstable_NormalPriority,Ac)))}\nfunction Cc(a){function b(b){return Bc(b,a)}if(0<jc.length){Bc(jc[0],a);for(var c=1;c<jc.length;c++){var d=jc[c];d.blockedOn===a&&(d.blockedOn=null)}}null!==kc&&Bc(kc,a);null!==lc&&Bc(lc,a);null!==mc&&Bc(mc,a);nc.forEach(b);oc.forEach(b);for(c=0;c<pc.length;c++)d=pc[c],d.blockedOn===a&&(d.blockedOn=null);for(;0<pc.length&&(c=pc[0],null===c.blockedOn);)vc(c),null===c.blockedOn&&pc.shift()}\nfunction Dc(a,b){var c={};c[a.toLowerCase()]=b.toLowerCase();c[\"Webkit\"+a]=\"webkit\"+b;c[\"Moz\"+a]=\"moz\"+b;return c}var Ec={animationend:Dc(\"Animation\",\"AnimationEnd\"),animationiteration:Dc(\"Animation\",\"AnimationIteration\"),animationstart:Dc(\"Animation\",\"AnimationStart\"),transitionend:Dc(\"Transition\",\"TransitionEnd\")},Fc={},Gc={};\nfa&&(Gc=document.createElement(\"div\").style,\"AnimationEvent\"in window||(delete Ec.animationend.animation,delete Ec.animationiteration.animation,delete Ec.animationstart.animation),\"TransitionEvent\"in window||delete Ec.transitionend.transition);function Hc(a){if(Fc[a])return Fc[a];if(!Ec[a])return a;var b=Ec[a],c;for(c in b)if(b.hasOwnProperty(c)&&c in Gc)return Fc[a]=b[c];return a}\nvar Ic=Hc(\"animationend\"),Jc=Hc(\"animationiteration\"),Kc=Hc(\"animationstart\"),Lc=Hc(\"transitionend\"),Mc=new Map,Nc=new Map,Oc=[\"abort\",\"abort\",Ic,\"animationEnd\",Jc,\"animationIteration\",Kc,\"animationStart\",\"canplay\",\"canPlay\",\"canplaythrough\",\"canPlayThrough\",\"durationchange\",\"durationChange\",\"emptied\",\"emptied\",\"encrypted\",\"encrypted\",\"ended\",\"ended\",\"error\",\"error\",\"gotpointercapture\",\"gotPointerCapture\",\"load\",\"load\",\"loadeddata\",\"loadedData\",\"loadedmetadata\",\"loadedMetadata\",\"loadstart\",\"loadStart\",\n\"lostpointercapture\",\"lostPointerCapture\",\"playing\",\"playing\",\"progress\",\"progress\",\"seeking\",\"seeking\",\"stalled\",\"stalled\",\"suspend\",\"suspend\",\"timeupdate\",\"timeUpdate\",Lc,\"transitionEnd\",\"waiting\",\"waiting\"];function Pc(a,b){for(var c=0;c<a.length;c+=2){var d=a[c],e=a[c+1];e=\"on\"+(e[0].toUpperCase()+e.slice(1));Nc.set(d,b);Mc.set(d,e);da(e,[d])}}var Qc=r.unstable_now;Qc();var F=8;\nfunction Rc(a){if(0!==(1&a))return F=15,1;if(0!==(2&a))return F=14,2;if(0!==(4&a))return F=13,4;var b=24&a;if(0!==b)return F=12,b;if(0!==(a&32))return F=11,32;b=192&a;if(0!==b)return F=10,b;if(0!==(a&256))return F=9,256;b=3584&a;if(0!==b)return F=8,b;if(0!==(a&4096))return F=7,4096;b=4186112&a;if(0!==b)return F=6,b;b=62914560&a;if(0!==b)return F=5,b;if(a&67108864)return F=4,67108864;if(0!==(a&134217728))return F=3,134217728;b=805306368&a;if(0!==b)return F=2,b;if(0!==(1073741824&a))return F=1,1073741824;\nF=8;return a}function Sc(a){switch(a){case 99:return 15;case 98:return 10;case 97:case 96:return 8;case 95:return 2;default:return 0}}function Tc(a){switch(a){case 15:case 14:return 99;case 13:case 12:case 11:case 10:return 98;case 9:case 8:case 7:case 6:case 4:case 5:return 97;case 3:case 2:case 1:return 95;case 0:return 90;default:throw Error(y(358,a));}}\nfunction Uc(a,b){var c=a.pendingLanes;if(0===c)return F=0;var d=0,e=0,f=a.expiredLanes,g=a.suspendedLanes,h=a.pingedLanes;if(0!==f)d=f,e=F=15;else if(f=c&134217727,0!==f){var k=f&~g;0!==k?(d=Rc(k),e=F):(h&=f,0!==h&&(d=Rc(h),e=F))}else f=c&~g,0!==f?(d=Rc(f),e=F):0!==h&&(d=Rc(h),e=F);if(0===d)return 0;d=31-Vc(d);d=c&((0>d?0:1<<d)<<1)-1;if(0!==b&&b!==d&&0===(b&g)){Rc(b);if(e<=F)return b;F=e}b=a.entangledLanes;if(0!==b)for(a=a.entanglements,b&=d;0<b;)c=31-Vc(b),e=1<<c,d|=a[c],b&=~e;return d}\nfunction Wc(a){a=a.pendingLanes&-1073741825;return 0!==a?a:a&1073741824?1073741824:0}function Xc(a,b){switch(a){case 15:return 1;case 14:return 2;case 12:return a=Yc(24&~b),0===a?Xc(10,b):a;case 10:return a=Yc(192&~b),0===a?Xc(8,b):a;case 8:return a=Yc(3584&~b),0===a&&(a=Yc(4186112&~b),0===a&&(a=512)),a;case 2:return b=Yc(805306368&~b),0===b&&(b=268435456),b}throw Error(y(358,a));}function Yc(a){return a&-a}function Zc(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}\nfunction $c(a,b,c){a.pendingLanes|=b;var d=b-1;a.suspendedLanes&=d;a.pingedLanes&=d;a=a.eventTimes;b=31-Vc(b);a[b]=c}var Vc=Math.clz32?Math.clz32:ad,bd=Math.log,cd=Math.LN2;function ad(a){return 0===a?32:31-(bd(a)/cd|0)|0}var dd=r.unstable_UserBlockingPriority,ed=r.unstable_runWithPriority,fd=!0;function gd(a,b,c,d){Kb||Ib();var e=hd,f=Kb;Kb=!0;try{Hb(e,a,b,c,d)}finally{(Kb=f)||Mb()}}function id(a,b,c,d){ed(dd,hd.bind(null,a,b,c,d))}\nfunction hd(a,b,c,d){if(fd){var e;if((e=0===(b&4))&&0<jc.length&&-1<qc.indexOf(a))a=rc(null,a,b,c,d),jc.push(a);else{var f=yc(a,b,c,d);if(null===f)e&&sc(a,d);else{if(e){if(-1<qc.indexOf(a)){a=rc(f,a,b,c,d);jc.push(a);return}if(uc(f,a,b,c,d))return;sc(a,d)}jd(a,b,d,null,c)}}}}\nfunction yc(a,b,c,d){var e=xb(d);e=wc(e);if(null!==e){var f=Zb(e);if(null===f)e=null;else{var g=f.tag;if(13===g){e=$b(f);if(null!==e)return e;e=null}else if(3===g){if(f.stateNode.hydrate)return 3===f.tag?f.stateNode.containerInfo:null;e=null}else f!==e&&(e=null)}}jd(a,b,d,e,c);return null}var kd=null,ld=null,md=null;\nfunction nd(){if(md)return md;var a,b=ld,c=b.length,d,e=\"value\"in kd?kd.value:kd.textContent,f=e.length;for(a=0;a<c&&b[a]===e[a];a++);var g=c-a;for(d=1;d<=g&&b[c-d]===e[f-d];d++);return md=e.slice(a,1<d?1-d:void 0)}function od(a){var b=a.keyCode;\"charCode\"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function pd(){return!0}function qd(){return!1}\nfunction rd(a){function b(b,d,e,f,g){this._reactName=b;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var c in a)a.hasOwnProperty(c)&&(b=a[c],this[c]=b?b(f):f[c]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?pd:qd;this.isPropagationStopped=qd;return this}m(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():\"unknown\"!==typeof a.returnValue&&\n(a.returnValue=!1),this.isDefaultPrevented=pd)},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():\"unknown\"!==typeof a.cancelBubble&&(a.cancelBubble=!0),this.isPropagationStopped=pd)},persist:function(){},isPersistent:pd});return b}\nvar sd={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},td=rd(sd),ud=m({},sd,{view:0,detail:0}),vd=rd(ud),wd,xd,yd,Ad=m({},ud,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:zd,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if(\"movementX\"in\na)return a.movementX;a!==yd&&(yd&&\"mousemove\"===a.type?(wd=a.screenX-yd.screenX,xd=a.screenY-yd.screenY):xd=wd=0,yd=a);return wd},movementY:function(a){return\"movementY\"in a?a.movementY:xd}}),Bd=rd(Ad),Cd=m({},Ad,{dataTransfer:0}),Dd=rd(Cd),Ed=m({},ud,{relatedTarget:0}),Fd=rd(Ed),Gd=m({},sd,{animationName:0,elapsedTime:0,pseudoElement:0}),Hd=rd(Gd),Id=m({},sd,{clipboardData:function(a){return\"clipboardData\"in a?a.clipboardData:window.clipboardData}}),Jd=rd(Id),Kd=m({},sd,{data:0}),Ld=rd(Kd),Md={Esc:\"Escape\",\nSpacebar:\" \",Left:\"ArrowLeft\",Up:\"ArrowUp\",Right:\"ArrowRight\",Down:\"ArrowDown\",Del:\"Delete\",Win:\"OS\",Menu:\"ContextMenu\",Apps:\"ContextMenu\",Scroll:\"ScrollLock\",MozPrintableKey:\"Unidentified\"},Nd={8:\"Backspace\",9:\"Tab\",12:\"Clear\",13:\"Enter\",16:\"Shift\",17:\"Control\",18:\"Alt\",19:\"Pause\",20:\"CapsLock\",27:\"Escape\",32:\" \",33:\"PageUp\",34:\"PageDown\",35:\"End\",36:\"Home\",37:\"ArrowLeft\",38:\"ArrowUp\",39:\"ArrowRight\",40:\"ArrowDown\",45:\"Insert\",46:\"Delete\",112:\"F1\",113:\"F2\",114:\"F3\",115:\"F4\",116:\"F5\",117:\"F6\",118:\"F7\",\n119:\"F8\",120:\"F9\",121:\"F10\",122:\"F11\",123:\"F12\",144:\"NumLock\",145:\"ScrollLock\",224:\"Meta\"},Od={Alt:\"altKey\",Control:\"ctrlKey\",Meta:\"metaKey\",Shift:\"shiftKey\"};function Pd(a){var b=this.nativeEvent;return b.getModifierState?b.getModifierState(a):(a=Od[a])?!!b[a]:!1}function zd(){return Pd}\nvar Qd=m({},ud,{key:function(a){if(a.key){var b=Md[a.key]||a.key;if(\"Unidentified\"!==b)return b}return\"keypress\"===a.type?(a=od(a),13===a?\"Enter\":String.fromCharCode(a)):\"keydown\"===a.type||\"keyup\"===a.type?Nd[a.keyCode]||\"Unidentified\":\"\"},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:zd,charCode:function(a){return\"keypress\"===a.type?od(a):0},keyCode:function(a){return\"keydown\"===a.type||\"keyup\"===a.type?a.keyCode:0},which:function(a){return\"keypress\"===\na.type?od(a):\"keydown\"===a.type||\"keyup\"===a.type?a.keyCode:0}}),Rd=rd(Qd),Sd=m({},Ad,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Td=rd(Sd),Ud=m({},ud,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:zd}),Vd=rd(Ud),Wd=m({},sd,{propertyName:0,elapsedTime:0,pseudoElement:0}),Xd=rd(Wd),Yd=m({},Ad,{deltaX:function(a){return\"deltaX\"in a?a.deltaX:\"wheelDeltaX\"in a?-a.wheelDeltaX:0},\ndeltaY:function(a){return\"deltaY\"in a?a.deltaY:\"wheelDeltaY\"in a?-a.wheelDeltaY:\"wheelDelta\"in a?-a.wheelDelta:0},deltaZ:0,deltaMode:0}),Zd=rd(Yd),$d=[9,13,27,32],ae=fa&&\"CompositionEvent\"in window,be=null;fa&&\"documentMode\"in document&&(be=document.documentMode);var ce=fa&&\"TextEvent\"in window&&!be,de=fa&&(!ae||be&&8<be&&11>=be),ee=String.fromCharCode(32),fe=!1;\nfunction ge(a,b){switch(a){case \"keyup\":return-1!==$d.indexOf(b.keyCode);case \"keydown\":return 229!==b.keyCode;case \"keypress\":case \"mousedown\":case \"focusout\":return!0;default:return!1}}function he(a){a=a.detail;return\"object\"===typeof a&&\"data\"in a?a.data:null}var ie=!1;function je(a,b){switch(a){case \"compositionend\":return he(b);case \"keypress\":if(32!==b.which)return null;fe=!0;return ee;case \"textInput\":return a=b.data,a===ee&&fe?null:a;default:return null}}\nfunction ke(a,b){if(ie)return\"compositionend\"===a||!ae&&ge(a,b)?(a=nd(),md=ld=kd=null,ie=!1,a):null;switch(a){case \"paste\":return null;case \"keypress\":if(!(b.ctrlKey||b.altKey||b.metaKey)||b.ctrlKey&&b.altKey){if(b.char&&1<b.char.length)return b.char;if(b.which)return String.fromCharCode(b.which)}return null;case \"compositionend\":return de&&\"ko\"!==b.locale?null:b.data;default:return null}}\nvar le={color:!0,date:!0,datetime:!0,\"datetime-local\":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function me(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return\"input\"===b?!!le[a.type]:\"textarea\"===b?!0:!1}function ne(a,b,c,d){Eb(d);b=oe(b,\"onChange\");0<b.length&&(c=new td(\"onChange\",\"change\",null,c,d),a.push({event:c,listeners:b}))}var pe=null,qe=null;function re(a){se(a,0)}function te(a){var b=ue(a);if(Wa(b))return a}\nfunction ve(a,b){if(\"change\"===a)return b}var we=!1;if(fa){var xe;if(fa){var ye=\"oninput\"in document;if(!ye){var ze=document.createElement(\"div\");ze.setAttribute(\"oninput\",\"return;\");ye=\"function\"===typeof ze.oninput}xe=ye}else xe=!1;we=xe&&(!document.documentMode||9<document.documentMode)}function Ae(){pe&&(pe.detachEvent(\"onpropertychange\",Be),qe=pe=null)}function Be(a){if(\"value\"===a.propertyName&&te(qe)){var b=[];ne(b,qe,a,xb(a));a=re;if(Kb)a(b);else{Kb=!0;try{Gb(a,b)}finally{Kb=!1,Mb()}}}}\nfunction Ce(a,b,c){\"focusin\"===a?(Ae(),pe=b,qe=c,pe.attachEvent(\"onpropertychange\",Be)):\"focusout\"===a&&Ae()}function De(a){if(\"selectionchange\"===a||\"keyup\"===a||\"keydown\"===a)return te(qe)}function Ee(a,b){if(\"click\"===a)return te(b)}function Fe(a,b){if(\"input\"===a||\"change\"===a)return te(b)}function Ge(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var He=\"function\"===typeof Object.is?Object.is:Ge,Ie=Object.prototype.hasOwnProperty;\nfunction Je(a,b){if(He(a,b))return!0;if(\"object\"!==typeof a||null===a||\"object\"!==typeof b||null===b)return!1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return!1;for(d=0;d<c.length;d++)if(!Ie.call(b,c[d])||!He(a[c[d]],b[c[d]]))return!1;return!0}function Ke(a){for(;a&&a.firstChild;)a=a.firstChild;return a}\nfunction Le(a,b){var c=Ke(a);a=0;for(var d;c;){if(3===c.nodeType){d=a+c.textContent.length;if(a<=b&&d>=b)return{node:c,offset:b-a};a=d}a:{for(;c;){if(c.nextSibling){c=c.nextSibling;break a}c=c.parentNode}c=void 0}c=Ke(c)}}function Me(a,b){return a&&b?a===b?!0:a&&3===a.nodeType?!1:b&&3===b.nodeType?Me(a,b.parentNode):\"contains\"in a?a.contains(b):a.compareDocumentPosition?!!(a.compareDocumentPosition(b)&16):!1:!1}\nfunction Ne(){for(var a=window,b=Xa();b instanceof a.HTMLIFrameElement;){try{var c=\"string\"===typeof b.contentWindow.location.href}catch(d){c=!1}if(c)a=b.contentWindow;else break;b=Xa(a.document)}return b}function Oe(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return b&&(\"input\"===b&&(\"text\"===a.type||\"search\"===a.type||\"tel\"===a.type||\"url\"===a.type||\"password\"===a.type)||\"textarea\"===b||\"true\"===a.contentEditable)}\nvar Pe=fa&&\"documentMode\"in document&&11>=document.documentMode,Qe=null,Re=null,Se=null,Te=!1;\nfunction Ue(a,b,c){var d=c.window===c?c.document:9===c.nodeType?c:c.ownerDocument;Te||null==Qe||Qe!==Xa(d)||(d=Qe,\"selectionStart\"in d&&Oe(d)?d={start:d.selectionStart,end:d.selectionEnd}:(d=(d.ownerDocument&&d.ownerDocument.defaultView||window).getSelection(),d={anchorNode:d.anchorNode,anchorOffset:d.anchorOffset,focusNode:d.focusNode,focusOffset:d.focusOffset}),Se&&Je(Se,d)||(Se=d,d=oe(Re,\"onSelect\"),0<d.length&&(b=new td(\"onSelect\",\"select\",null,b,c),a.push({event:b,listeners:d}),b.target=Qe)))}\nPc(\"cancel cancel click click close close contextmenu contextMenu copy copy cut cut auxclick auxClick dblclick doubleClick dragend dragEnd dragstart dragStart drop drop focusin focus focusout blur input input invalid invalid keydown keyDown keypress keyPress keyup keyUp mousedown mouseDown mouseup mouseUp paste paste pause pause play play pointercancel pointerCancel pointerdown pointerDown pointerup pointerUp ratechange rateChange reset reset seeked seeked submit submit touchcancel touchCancel touchend touchEnd touchstart touchStart volumechange volumeChange\".split(\" \"),\n0);Pc(\"drag drag dragenter dragEnter dragexit dragExit dragleave dragLeave dragover dragOver mousemove mouseMove mouseout mouseOut mouseover mouseOver pointermove pointerMove pointerout pointerOut pointerover pointerOver scroll scroll toggle toggle touchmove touchMove wheel wheel\".split(\" \"),1);Pc(Oc,2);for(var Ve=\"change selectionchange textInput compositionstart compositionend compositionupdate\".split(\" \"),We=0;We<Ve.length;We++)Nc.set(Ve[We],0);ea(\"onMouseEnter\",[\"mouseout\",\"mouseover\"]);\nea(\"onMouseLeave\",[\"mouseout\",\"mouseover\"]);ea(\"onPointerEnter\",[\"pointerout\",\"pointerover\"]);ea(\"onPointerLeave\",[\"pointerout\",\"pointerover\"]);da(\"onChange\",\"change click focusin focusout input keydown keyup selectionchange\".split(\" \"));da(\"onSelect\",\"focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange\".split(\" \"));da(\"onBeforeInput\",[\"compositionend\",\"keypress\",\"textInput\",\"paste\"]);da(\"onCompositionEnd\",\"compositionend focusout keydown keypress keyup mousedown\".split(\" \"));\nda(\"onCompositionStart\",\"compositionstart focusout keydown keypress keyup mousedown\".split(\" \"));da(\"onCompositionUpdate\",\"compositionupdate focusout keydown keypress keyup mousedown\".split(\" \"));var Xe=\"abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange seeked seeking stalled suspend timeupdate volumechange waiting\".split(\" \"),Ye=new Set(\"cancel close invalid load scroll toggle\".split(\" \").concat(Xe));\nfunction Ze(a,b,c){var d=a.type||\"unknown-event\";a.currentTarget=c;Yb(d,b,void 0,a);a.currentTarget=null}\nfunction se(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=d.listeners;a:{var f=void 0;if(b)for(var g=d.length-1;0<=g;g--){var h=d[g],k=h.instance,l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;Ze(e,h,l);f=k}else for(g=0;g<d.length;g++){h=d[g];k=h.instance;l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;Ze(e,h,l);f=k}}}if(Ub)throw a=Vb,Ub=!1,Vb=null,a;}\nfunction G(a,b){var c=$e(b),d=a+\"__bubble\";c.has(d)||(af(b,a,2,!1),c.add(d))}var bf=\"_reactListening\"+Math.random().toString(36).slice(2);function cf(a){a[bf]||(a[bf]=!0,ba.forEach(function(b){Ye.has(b)||df(b,!1,a,null);df(b,!0,a,null)}))}\nfunction df(a,b,c,d){var e=4<arguments.length&&void 0!==arguments[4]?arguments[4]:0,f=c;\"selectionchange\"===a&&9!==c.nodeType&&(f=c.ownerDocument);if(null!==d&&!b&&Ye.has(a)){if(\"scroll\"!==a)return;e|=2;f=d}var g=$e(f),h=a+\"__\"+(b?\"capture\":\"bubble\");g.has(h)||(b&&(e|=4),af(f,a,e,b),g.add(h))}\nfunction af(a,b,c,d){var e=Nc.get(b);switch(void 0===e?2:e){case 0:e=gd;break;case 1:e=id;break;default:e=hd}c=e.bind(null,b,c,a);e=void 0;!Pb||\"touchstart\"!==b&&\"touchmove\"!==b&&\"wheel\"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1)}\nfunction jd(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var k=g.tag;if(3===k||4===k)if(k=g.stateNode.containerInfo,k===e||8===k.nodeType&&k.parentNode===e)return;g=g.return}for(;null!==h;){g=wc(h);if(null===g)return;k=g.tag;if(5===k||6===k){d=f=g;continue a}h=h.parentNode}}d=d.return}Nb(function(){var d=f,e=xb(c),g=[];\na:{var h=Mc.get(a);if(void 0!==h){var k=td,x=a;switch(a){case \"keypress\":if(0===od(c))break a;case \"keydown\":case \"keyup\":k=Rd;break;case \"focusin\":x=\"focus\";k=Fd;break;case \"focusout\":x=\"blur\";k=Fd;break;case \"beforeblur\":case \"afterblur\":k=Fd;break;case \"click\":if(2===c.button)break a;case \"auxclick\":case \"dblclick\":case \"mousedown\":case \"mousemove\":case \"mouseup\":case \"mouseout\":case \"mouseover\":case \"contextmenu\":k=Bd;break;case \"drag\":case \"dragend\":case \"dragenter\":case \"dragexit\":case \"dragleave\":case \"dragover\":case \"dragstart\":case \"drop\":k=\nDd;break;case \"touchcancel\":case \"touchend\":case \"touchmove\":case \"touchstart\":k=Vd;break;case Ic:case Jc:case Kc:k=Hd;break;case Lc:k=Xd;break;case \"scroll\":k=vd;break;case \"wheel\":k=Zd;break;case \"copy\":case \"cut\":case \"paste\":k=Jd;break;case \"gotpointercapture\":case \"lostpointercapture\":case \"pointercancel\":case \"pointerdown\":case \"pointermove\":case \"pointerout\":case \"pointerover\":case \"pointerup\":k=Td}var w=0!==(b&4),z=!w&&\"scroll\"===a,u=w?null!==h?h+\"Capture\":null:h;w=[];for(var t=d,q;null!==\nt;){q=t;var v=q.stateNode;5===q.tag&&null!==v&&(q=v,null!==u&&(v=Ob(t,u),null!=v&&w.push(ef(t,v,q))));if(z)break;t=t.return}0<w.length&&(h=new k(h,x,null,c,e),g.push({event:h,listeners:w}))}}if(0===(b&7)){a:{h=\"mouseover\"===a||\"pointerover\"===a;k=\"mouseout\"===a||\"pointerout\"===a;if(h&&0===(b&16)&&(x=c.relatedTarget||c.fromElement)&&(wc(x)||x[ff]))break a;if(k||h){h=e.window===e?e:(h=e.ownerDocument)?h.defaultView||h.parentWindow:window;if(k){if(x=c.relatedTarget||c.toElement,k=d,x=x?wc(x):null,null!==\nx&&(z=Zb(x),x!==z||5!==x.tag&&6!==x.tag))x=null}else k=null,x=d;if(k!==x){w=Bd;v=\"onMouseLeave\";u=\"onMouseEnter\";t=\"mouse\";if(\"pointerout\"===a||\"pointerover\"===a)w=Td,v=\"onPointerLeave\",u=\"onPointerEnter\",t=\"pointer\";z=null==k?h:ue(k);q=null==x?h:ue(x);h=new w(v,t+\"leave\",k,c,e);h.target=z;h.relatedTarget=q;v=null;wc(e)===d&&(w=new w(u,t+\"enter\",x,c,e),w.target=q,w.relatedTarget=z,v=w);z=v;if(k&&x)b:{w=k;u=x;t=0;for(q=w;q;q=gf(q))t++;q=0;for(v=u;v;v=gf(v))q++;for(;0<t-q;)w=gf(w),t--;for(;0<q-t;)u=\ngf(u),q--;for(;t--;){if(w===u||null!==u&&w===u.alternate)break b;w=gf(w);u=gf(u)}w=null}else w=null;null!==k&&hf(g,h,k,w,!1);null!==x&&null!==z&&hf(g,z,x,w,!0)}}}a:{h=d?ue(d):window;k=h.nodeName&&h.nodeName.toLowerCase();if(\"select\"===k||\"input\"===k&&\"file\"===h.type)var J=ve;else if(me(h))if(we)J=Fe;else{J=De;var K=Ce}else(k=h.nodeName)&&\"input\"===k.toLowerCase()&&(\"checkbox\"===h.type||\"radio\"===h.type)&&(J=Ee);if(J&&(J=J(a,d))){ne(g,J,c,e);break a}K&&K(a,h,d);\"focusout\"===a&&(K=h._wrapperState)&&\nK.controlled&&\"number\"===h.type&&bb(h,\"number\",h.value)}K=d?ue(d):window;switch(a){case \"focusin\":if(me(K)||\"true\"===K.contentEditable)Qe=K,Re=d,Se=null;break;case \"focusout\":Se=Re=Qe=null;break;case \"mousedown\":Te=!0;break;case \"contextmenu\":case \"mouseup\":case \"dragend\":Te=!1;Ue(g,c,e);break;case \"selectionchange\":if(Pe)break;case \"keydown\":case \"keyup\":Ue(g,c,e)}var Q;if(ae)b:{switch(a){case \"compositionstart\":var L=\"onCompositionStart\";break b;case \"compositionend\":L=\"onCompositionEnd\";break b;\ncase \"compositionupdate\":L=\"onCompositionUpdate\";break b}L=void 0}else ie?ge(a,c)&&(L=\"onCompositionEnd\"):\"keydown\"===a&&229===c.keyCode&&(L=\"onCompositionStart\");L&&(de&&\"ko\"!==c.locale&&(ie||\"onCompositionStart\"!==L?\"onCompositionEnd\"===L&&ie&&(Q=nd()):(kd=e,ld=\"value\"in kd?kd.value:kd.textContent,ie=!0)),K=oe(d,L),0<K.length&&(L=new Ld(L,a,null,c,e),g.push({event:L,listeners:K}),Q?L.data=Q:(Q=he(c),null!==Q&&(L.data=Q))));if(Q=ce?je(a,c):ke(a,c))d=oe(d,\"onBeforeInput\"),0<d.length&&(e=new Ld(\"onBeforeInput\",\n\"beforeinput\",null,c,e),g.push({event:e,listeners:d}),e.data=Q)}se(g,b)})}function ef(a,b,c){return{instance:a,listener:b,currentTarget:c}}function oe(a,b){for(var c=b+\"Capture\",d=[];null!==a;){var e=a,f=e.stateNode;5===e.tag&&null!==f&&(e=f,f=Ob(a,c),null!=f&&d.unshift(ef(a,f,e)),f=Ob(a,b),null!=f&&d.push(ef(a,f,e)));a=a.return}return d}function gf(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag);return a?a:null}\nfunction hf(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,k=h.alternate,l=h.stateNode;if(null!==k&&k===d)break;5===h.tag&&null!==l&&(h=l,e?(k=Ob(c,f),null!=k&&g.unshift(ef(c,k,h))):e||(k=Ob(c,f),null!=k&&g.push(ef(c,k,h))));c=c.return}0!==g.length&&a.push({event:b,listeners:g})}function jf(){}var kf=null,lf=null;function mf(a,b){switch(a){case \"button\":case \"input\":case \"select\":case \"textarea\":return!!b.autoFocus}return!1}\nfunction nf(a,b){return\"textarea\"===a||\"option\"===a||\"noscript\"===a||\"string\"===typeof b.children||\"number\"===typeof b.children||\"object\"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}var of=\"function\"===typeof setTimeout?setTimeout:void 0,pf=\"function\"===typeof clearTimeout?clearTimeout:void 0;function qf(a){1===a.nodeType?a.textContent=\"\":9===a.nodeType&&(a=a.body,null!=a&&(a.textContent=\"\"))}\nfunction rf(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break}return a}function sf(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if(\"$\"===c||\"$!\"===c||\"$?\"===c){if(0===b)return a;b--}else\"/$\"===c&&b++}a=a.previousSibling}return null}var tf=0;function uf(a){return{$$typeof:Ga,toString:a,valueOf:a}}var vf=Math.random().toString(36).slice(2),wf=\"__reactFiber$\"+vf,xf=\"__reactProps$\"+vf,ff=\"__reactContainer$\"+vf,yf=\"__reactEvents$\"+vf;\nfunction wc(a){var b=a[wf];if(b)return b;for(var c=a.parentNode;c;){if(b=c[ff]||c[wf]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=sf(a);null!==a;){if(c=a[wf])return c;a=sf(a)}return b}a=c;c=a.parentNode}return null}function Cb(a){a=a[wf]||a[ff];return!a||5!==a.tag&&6!==a.tag&&13!==a.tag&&3!==a.tag?null:a}function ue(a){if(5===a.tag||6===a.tag)return a.stateNode;throw Error(y(33));}function Db(a){return a[xf]||null}\nfunction $e(a){var b=a[yf];void 0===b&&(b=a[yf]=new Set);return b}var zf=[],Af=-1;function Bf(a){return{current:a}}function H(a){0>Af||(a.current=zf[Af],zf[Af]=null,Af--)}function I(a,b){Af++;zf[Af]=a.current;a.current=b}var Cf={},M=Bf(Cf),N=Bf(!1),Df=Cf;\nfunction Ef(a,b){var c=a.type.contextTypes;if(!c)return Cf;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}function Ff(a){a=a.childContextTypes;return null!==a&&void 0!==a}function Gf(){H(N);H(M)}function Hf(a,b,c){if(M.current!==Cf)throw Error(y(168));I(M,b);I(N,c)}\nfunction If(a,b,c){var d=a.stateNode;a=b.childContextTypes;if(\"function\"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in a))throw Error(y(108,Ra(b)||\"Unknown\",e));return m({},c,d)}function Jf(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Cf;Df=M.current;I(M,a);I(N,N.current);return!0}function Kf(a,b,c){var d=a.stateNode;if(!d)throw Error(y(169));c?(a=If(a,b,Df),d.__reactInternalMemoizedMergedChildContext=a,H(N),H(M),I(M,a)):H(N);I(N,c)}\nvar Lf=null,Mf=null,Nf=r.unstable_runWithPriority,Of=r.unstable_scheduleCallback,Pf=r.unstable_cancelCallback,Qf=r.unstable_shouldYield,Rf=r.unstable_requestPaint,Sf=r.unstable_now,Tf=r.unstable_getCurrentPriorityLevel,Uf=r.unstable_ImmediatePriority,Vf=r.unstable_UserBlockingPriority,Wf=r.unstable_NormalPriority,Xf=r.unstable_LowPriority,Yf=r.unstable_IdlePriority,Zf={},$f=void 0!==Rf?Rf:function(){},ag=null,bg=null,cg=!1,dg=Sf(),O=1E4>dg?Sf:function(){return Sf()-dg};\nfunction eg(){switch(Tf()){case Uf:return 99;case Vf:return 98;case Wf:return 97;case Xf:return 96;case Yf:return 95;default:throw Error(y(332));}}function fg(a){switch(a){case 99:return Uf;case 98:return Vf;case 97:return Wf;case 96:return Xf;case 95:return Yf;default:throw Error(y(332));}}function gg(a,b){a=fg(a);return Nf(a,b)}function hg(a,b,c){a=fg(a);return Of(a,b,c)}function ig(){if(null!==bg){var a=bg;bg=null;Pf(a)}jg()}\nfunction jg(){if(!cg&&null!==ag){cg=!0;var a=0;try{var b=ag;gg(99,function(){for(;a<b.length;a++){var c=b[a];do c=c(!0);while(null!==c)}});ag=null}catch(c){throw null!==ag&&(ag=ag.slice(a+1)),Of(Uf,ig),c;}finally{cg=!1}}}var kg=ra.ReactCurrentBatchConfig;function lg(a,b){if(a&&a.defaultProps){b=m({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}var mg=Bf(null),ng=null,og=null,pg=null;function qg(){pg=og=ng=null}\nfunction rg(a){var b=mg.current;H(mg);a.type._context._currentValue=b}function sg(a,b){for(;null!==a;){var c=a.alternate;if((a.childLanes&b)===b)if(null===c||(c.childLanes&b)===b)break;else c.childLanes|=b;else a.childLanes|=b,null!==c&&(c.childLanes|=b);a=a.return}}function tg(a,b){ng=a;pg=og=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(ug=!0),a.firstContext=null)}\nfunction vg(a,b){if(pg!==a&&!1!==b&&0!==b){if(\"number\"!==typeof b||1073741823===b)pg=a,b=1073741823;b={context:a,observedBits:b,next:null};if(null===og){if(null===ng)throw Error(y(308));og=b;ng.dependencies={lanes:0,firstContext:b,responders:null}}else og=og.next=b}return a._currentValue}var wg=!1;function xg(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null},effects:null}}\nfunction yg(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,effects:a.effects})}function zg(a,b){return{eventTime:a,lane:b,tag:0,payload:null,callback:null,next:null}}function Ag(a,b){a=a.updateQueue;if(null!==a){a=a.shared;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}}\nfunction Bg(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={eventTime:c.eventTime,lane:c.lane,tag:c.tag,payload:c.payload,callback:c.callback,next:null};null===f?e=f=g:f=f.next=g;c=c.next}while(null!==c);null===f?e=f=b:f=f.next=b}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,effects:d.effects};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=\nb;c.lastBaseUpdate=b}\nfunction Cg(a,b,c,d){var e=a.updateQueue;wg=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var k=h,l=k.next;k.next=null;null===g?f=l:g.next=l;g=k;var n=a.alternate;if(null!==n){n=n.updateQueue;var A=n.lastBaseUpdate;A!==g&&(null===A?n.firstBaseUpdate=l:A.next=l,n.lastBaseUpdate=k)}}if(null!==f){A=e.baseState;g=0;n=l=k=null;do{h=f.lane;var p=f.eventTime;if((d&h)===h){null!==n&&(n=n.next={eventTime:p,lane:0,tag:f.tag,payload:f.payload,callback:f.callback,\nnext:null});a:{var C=a,x=f;h=b;p=c;switch(x.tag){case 1:C=x.payload;if(\"function\"===typeof C){A=C.call(p,A,h);break a}A=C;break a;case 3:C.flags=C.flags&-4097|64;case 0:C=x.payload;h=\"function\"===typeof C?C.call(p,A,h):C;if(null===h||void 0===h)break a;A=m({},A,h);break a;case 2:wg=!0}}null!==f.callback&&(a.flags|=32,h=e.effects,null===h?e.effects=[f]:h.push(f))}else p={eventTime:p,lane:h,tag:f.tag,payload:f.payload,callback:f.callback,next:null},null===n?(l=n=p,k=A):n=n.next=p,g|=h;f=f.next;if(null===\nf)if(h=e.shared.pending,null===h)break;else f=h.next,h.next=null,e.lastBaseUpdate=h,e.shared.pending=null}while(1);null===n&&(k=A);e.baseState=k;e.firstBaseUpdate=l;e.lastBaseUpdate=n;Dg|=g;a.lanes=g;a.memoizedState=A}}function Eg(a,b,c){a=b.effects;b.effects=null;if(null!==a)for(b=0;b<a.length;b++){var d=a[b],e=d.callback;if(null!==e){d.callback=null;d=c;if(\"function\"!==typeof e)throw Error(y(191,e));e.call(d)}}}var Fg=(new aa.Component).refs;\nfunction Gg(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:m({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c)}\nvar Kg={isMounted:function(a){return(a=a._reactInternals)?Zb(a)===a:!1},enqueueSetState:function(a,b,c){a=a._reactInternals;var d=Hg(),e=Ig(a),f=zg(d,e);f.payload=b;void 0!==c&&null!==c&&(f.callback=c);Ag(a,f);Jg(a,e,d)},enqueueReplaceState:function(a,b,c){a=a._reactInternals;var d=Hg(),e=Ig(a),f=zg(d,e);f.tag=1;f.payload=b;void 0!==c&&null!==c&&(f.callback=c);Ag(a,f);Jg(a,e,d)},enqueueForceUpdate:function(a,b){a=a._reactInternals;var c=Hg(),d=Ig(a),e=zg(c,d);e.tag=2;void 0!==b&&null!==b&&(e.callback=\nb);Ag(a,e);Jg(a,d,c)}};function Lg(a,b,c,d,e,f,g){a=a.stateNode;return\"function\"===typeof a.shouldComponentUpdate?a.shouldComponentUpdate(d,f,g):b.prototype&&b.prototype.isPureReactComponent?!Je(c,d)||!Je(e,f):!0}\nfunction Mg(a,b,c){var d=!1,e=Cf;var f=b.contextType;\"object\"===typeof f&&null!==f?f=vg(f):(e=Ff(b)?Df:M.current,d=b.contextTypes,f=(d=null!==d&&void 0!==d)?Ef(a,e):Cf);b=new b(c,f);a.memoizedState=null!==b.state&&void 0!==b.state?b.state:null;b.updater=Kg;a.stateNode=b;b._reactInternals=a;d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=e,a.__reactInternalMemoizedMaskedChildContext=f);return b}\nfunction Ng(a,b,c,d){a=b.state;\"function\"===typeof b.componentWillReceiveProps&&b.componentWillReceiveProps(c,d);\"function\"===typeof b.UNSAFE_componentWillReceiveProps&&b.UNSAFE_componentWillReceiveProps(c,d);b.state!==a&&Kg.enqueueReplaceState(b,b.state,null)}\nfunction Og(a,b,c,d){var e=a.stateNode;e.props=c;e.state=a.memoizedState;e.refs=Fg;xg(a);var f=b.contextType;\"object\"===typeof f&&null!==f?e.context=vg(f):(f=Ff(b)?Df:M.current,e.context=Ef(a,f));Cg(a,c,e,d);e.state=a.memoizedState;f=b.getDerivedStateFromProps;\"function\"===typeof f&&(Gg(a,b,f,c),e.state=a.memoizedState);\"function\"===typeof b.getDerivedStateFromProps||\"function\"===typeof e.getSnapshotBeforeUpdate||\"function\"!==typeof e.UNSAFE_componentWillMount&&\"function\"!==typeof e.componentWillMount||\n(b=e.state,\"function\"===typeof e.componentWillMount&&e.componentWillMount(),\"function\"===typeof e.UNSAFE_componentWillMount&&e.UNSAFE_componentWillMount(),b!==e.state&&Kg.enqueueReplaceState(e,e.state,null),Cg(a,c,e,d),e.state=a.memoizedState);\"function\"===typeof e.componentDidMount&&(a.flags|=4)}var Pg=Array.isArray;\nfunction Qg(a,b,c){a=c.ref;if(null!==a&&\"function\"!==typeof a&&\"object\"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(y(309));var d=c.stateNode}if(!d)throw Error(y(147,a));var e=\"\"+a;if(null!==b&&null!==b.ref&&\"function\"===typeof b.ref&&b.ref._stringRef===e)return b.ref;b=function(a){var b=d.refs;b===Fg&&(b=d.refs={});null===a?delete b[e]:b[e]=a};b._stringRef=e;return b}if(\"string\"!==typeof a)throw Error(y(284));if(!c._owner)throw Error(y(290,a));}return a}\nfunction Rg(a,b){if(\"textarea\"!==a.type)throw Error(y(31,\"[object Object]\"===Object.prototype.toString.call(b)?\"object with keys {\"+Object.keys(b).join(\", \")+\"}\":b));}\nfunction Sg(a){function b(b,c){if(a){var d=b.lastEffect;null!==d?(d.nextEffect=c,b.lastEffect=c):b.firstEffect=b.lastEffect=c;c.nextEffect=null;c.flags=8}}function c(c,d){if(!a)return null;for(;null!==d;)b(c,d),d=d.sibling;return null}function d(a,b){for(a=new Map;null!==b;)null!==b.key?a.set(b.key,b):a.set(b.index,b),b=b.sibling;return a}function e(a,b){a=Tg(a,b);a.index=0;a.sibling=null;return a}function f(b,c,d){b.index=d;if(!a)return c;d=b.alternate;if(null!==d)return d=d.index,d<c?(b.flags=2,\nc):d;b.flags=2;return c}function g(b){a&&null===b.alternate&&(b.flags=2);return b}function h(a,b,c,d){if(null===b||6!==b.tag)return b=Ug(c,a.mode,d),b.return=a,b;b=e(b,c);b.return=a;return b}function k(a,b,c,d){if(null!==b&&b.elementType===c.type)return d=e(b,c.props),d.ref=Qg(a,b,c),d.return=a,d;d=Vg(c.type,c.key,c.props,null,a.mode,d);d.ref=Qg(a,b,c);d.return=a;return d}function l(a,b,c,d){if(null===b||4!==b.tag||b.stateNode.containerInfo!==c.containerInfo||b.stateNode.implementation!==c.implementation)return b=\nWg(c,a.mode,d),b.return=a,b;b=e(b,c.children||[]);b.return=a;return b}function n(a,b,c,d,f){if(null===b||7!==b.tag)return b=Xg(c,a.mode,d,f),b.return=a,b;b=e(b,c);b.return=a;return b}function A(a,b,c){if(\"string\"===typeof b||\"number\"===typeof b)return b=Ug(\"\"+b,a.mode,c),b.return=a,b;if(\"object\"===typeof b&&null!==b){switch(b.$$typeof){case sa:return c=Vg(b.type,b.key,b.props,null,a.mode,c),c.ref=Qg(a,null,b),c.return=a,c;case ta:return b=Wg(b,a.mode,c),b.return=a,b}if(Pg(b)||La(b))return b=Xg(b,\na.mode,c,null),b.return=a,b;Rg(a,b)}return null}function p(a,b,c,d){var e=null!==b?b.key:null;if(\"string\"===typeof c||\"number\"===typeof c)return null!==e?null:h(a,b,\"\"+c,d);if(\"object\"===typeof c&&null!==c){switch(c.$$typeof){case sa:return c.key===e?c.type===ua?n(a,b,c.props.children,d,e):k(a,b,c,d):null;case ta:return c.key===e?l(a,b,c,d):null}if(Pg(c)||La(c))return null!==e?null:n(a,b,c,d,null);Rg(a,c)}return null}function C(a,b,c,d,e){if(\"string\"===typeof d||\"number\"===typeof d)return a=a.get(c)||\nnull,h(b,a,\"\"+d,e);if(\"object\"===typeof d&&null!==d){switch(d.$$typeof){case sa:return a=a.get(null===d.key?c:d.key)||null,d.type===ua?n(b,a,d.props.children,e,d.key):k(b,a,d,e);case ta:return a=a.get(null===d.key?c:d.key)||null,l(b,a,d,e)}if(Pg(d)||La(d))return a=a.get(c)||null,n(b,a,d,e,null);Rg(b,d)}return null}function x(e,g,h,k){for(var l=null,t=null,u=g,z=g=0,q=null;null!==u&&z<h.length;z++){u.index>z?(q=u,u=null):q=u.sibling;var n=p(e,u,h[z],k);if(null===n){null===u&&(u=q);break}a&&u&&null===\nn.alternate&&b(e,u);g=f(n,g,z);null===t?l=n:t.sibling=n;t=n;u=q}if(z===h.length)return c(e,u),l;if(null===u){for(;z<h.length;z++)u=A(e,h[z],k),null!==u&&(g=f(u,g,z),null===t?l=u:t.sibling=u,t=u);return l}for(u=d(e,u);z<h.length;z++)q=C(u,e,z,h[z],k),null!==q&&(a&&null!==q.alternate&&u.delete(null===q.key?z:q.key),g=f(q,g,z),null===t?l=q:t.sibling=q,t=q);a&&u.forEach(function(a){return b(e,a)});return l}function w(e,g,h,k){var l=La(h);if(\"function\"!==typeof l)throw Error(y(150));h=l.call(h);if(null==\nh)throw Error(y(151));for(var t=l=null,u=g,z=g=0,q=null,n=h.next();null!==u&&!n.done;z++,n=h.next()){u.index>z?(q=u,u=null):q=u.sibling;var w=p(e,u,n.value,k);if(null===w){null===u&&(u=q);break}a&&u&&null===w.alternate&&b(e,u);g=f(w,g,z);null===t?l=w:t.sibling=w;t=w;u=q}if(n.done)return c(e,u),l;if(null===u){for(;!n.done;z++,n=h.next())n=A(e,n.value,k),null!==n&&(g=f(n,g,z),null===t?l=n:t.sibling=n,t=n);return l}for(u=d(e,u);!n.done;z++,n=h.next())n=C(u,e,z,n.value,k),null!==n&&(a&&null!==n.alternate&&\nu.delete(null===n.key?z:n.key),g=f(n,g,z),null===t?l=n:t.sibling=n,t=n);a&&u.forEach(function(a){return b(e,a)});return l}return function(a,d,f,h){var k=\"object\"===typeof f&&null!==f&&f.type===ua&&null===f.key;k&&(f=f.props.children);var l=\"object\"===typeof f&&null!==f;if(l)switch(f.$$typeof){case sa:a:{l=f.key;for(k=d;null!==k;){if(k.key===l){switch(k.tag){case 7:if(f.type===ua){c(a,k.sibling);d=e(k,f.props.children);d.return=a;a=d;break a}break;default:if(k.elementType===f.type){c(a,k.sibling);\nd=e(k,f.props);d.ref=Qg(a,k,f);d.return=a;a=d;break a}}c(a,k);break}else b(a,k);k=k.sibling}f.type===ua?(d=Xg(f.props.children,a.mode,h,f.key),d.return=a,a=d):(h=Vg(f.type,f.key,f.props,null,a.mode,h),h.ref=Qg(a,d,f),h.return=a,a=h)}return g(a);case ta:a:{for(k=f.key;null!==d;){if(d.key===k)if(4===d.tag&&d.stateNode.containerInfo===f.containerInfo&&d.stateNode.implementation===f.implementation){c(a,d.sibling);d=e(d,f.children||[]);d.return=a;a=d;break a}else{c(a,d);break}else b(a,d);d=d.sibling}d=\nWg(f,a.mode,h);d.return=a;a=d}return g(a)}if(\"string\"===typeof f||\"number\"===typeof f)return f=\"\"+f,null!==d&&6===d.tag?(c(a,d.sibling),d=e(d,f),d.return=a,a=d):(c(a,d),d=Ug(f,a.mode,h),d.return=a,a=d),g(a);if(Pg(f))return x(a,d,f,h);if(La(f))return w(a,d,f,h);l&&Rg(a,f);if(\"undefined\"===typeof f&&!k)switch(a.tag){case 1:case 22:case 0:case 11:case 15:throw Error(y(152,Ra(a.type)||\"Component\"));}return c(a,d)}}var Yg=Sg(!0),Zg=Sg(!1),$g={},ah=Bf($g),bh=Bf($g),ch=Bf($g);\nfunction dh(a){if(a===$g)throw Error(y(174));return a}function eh(a,b){I(ch,b);I(bh,a);I(ah,$g);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?b.namespaceURI:mb(null,\"\");break;default:a=8===a?b.parentNode:b,b=a.namespaceURI||null,a=a.tagName,b=mb(b,a)}H(ah);I(ah,b)}function fh(){H(ah);H(bh);H(ch)}function gh(a){dh(ch.current);var b=dh(ah.current);var c=mb(b,a.type);b!==c&&(I(bh,a),I(ah,c))}function hh(a){bh.current===a&&(H(ah),H(bh))}var P=Bf(0);\nfunction ih(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||\"$?\"===c.data||\"$!\"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&64))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var jh=null,kh=null,lh=!1;\nfunction mh(a,b){var c=nh(5,null,null,0);c.elementType=\"DELETED\";c.type=\"DELETED\";c.stateNode=b;c.return=a;c.flags=8;null!==a.lastEffect?(a.lastEffect.nextEffect=c,a.lastEffect=c):a.firstEffect=a.lastEffect=c}function oh(a,b){switch(a.tag){case 5:var c=a.type;b=1!==b.nodeType||c.toLowerCase()!==b.nodeName.toLowerCase()?null:b;return null!==b?(a.stateNode=b,!0):!1;case 6:return b=\"\"===a.pendingProps||3!==b.nodeType?null:b,null!==b?(a.stateNode=b,!0):!1;case 13:return!1;default:return!1}}\nfunction ph(a){if(lh){var b=kh;if(b){var c=b;if(!oh(a,b)){b=rf(c.nextSibling);if(!b||!oh(a,b)){a.flags=a.flags&-1025|2;lh=!1;jh=a;return}mh(jh,c)}jh=a;kh=rf(b.firstChild)}else a.flags=a.flags&-1025|2,lh=!1,jh=a}}function qh(a){for(a=a.return;null!==a&&5!==a.tag&&3!==a.tag&&13!==a.tag;)a=a.return;jh=a}\nfunction rh(a){if(a!==jh)return!1;if(!lh)return qh(a),lh=!0,!1;var b=a.type;if(5!==a.tag||\"head\"!==b&&\"body\"!==b&&!nf(b,a.memoizedProps))for(b=kh;b;)mh(a,b),b=rf(b.nextSibling);qh(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(y(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType){var c=a.data;if(\"/$\"===c){if(0===b){kh=rf(a.nextSibling);break a}b--}else\"$\"!==c&&\"$!\"!==c&&\"$?\"!==c||b++}a=a.nextSibling}kh=null}}else kh=jh?rf(a.stateNode.nextSibling):null;return!0}\nfunction sh(){kh=jh=null;lh=!1}var th=[];function uh(){for(var a=0;a<th.length;a++)th[a]._workInProgressVersionPrimary=null;th.length=0}var vh=ra.ReactCurrentDispatcher,wh=ra.ReactCurrentBatchConfig,xh=0,R=null,S=null,T=null,yh=!1,zh=!1;function Ah(){throw Error(y(321));}function Bh(a,b){if(null===b)return!1;for(var c=0;c<b.length&&c<a.length;c++)if(!He(a[c],b[c]))return!1;return!0}\nfunction Ch(a,b,c,d,e,f){xh=f;R=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;vh.current=null===a||null===a.memoizedState?Dh:Eh;a=c(d,e);if(zh){f=0;do{zh=!1;if(!(25>f))throw Error(y(301));f+=1;T=S=null;b.updateQueue=null;vh.current=Fh;a=c(d,e)}while(zh)}vh.current=Gh;b=null!==S&&null!==S.next;xh=0;T=S=R=null;yh=!1;if(b)throw Error(y(300));return a}function Hh(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===T?R.memoizedState=T=a:T=T.next=a;return T}\nfunction Ih(){if(null===S){var a=R.alternate;a=null!==a?a.memoizedState:null}else a=S.next;var b=null===T?R.memoizedState:T.next;if(null!==b)T=b,S=a;else{if(null===a)throw Error(y(310));S=a;a={memoizedState:S.memoizedState,baseState:S.baseState,baseQueue:S.baseQueue,queue:S.queue,next:null};null===T?R.memoizedState=T=a:T=T.next=a}return T}function Jh(a,b){return\"function\"===typeof b?b(a):b}\nfunction Kh(a){var b=Ih(),c=b.queue;if(null===c)throw Error(y(311));c.lastRenderedReducer=a;var d=S,e=d.baseQueue,f=c.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g}d.baseQueue=e=f;c.pending=null}if(null!==e){e=e.next;d=d.baseState;var h=g=f=null,k=e;do{var l=k.lane;if((xh&l)===l)null!==h&&(h=h.next={lane:0,action:k.action,eagerReducer:k.eagerReducer,eagerState:k.eagerState,next:null}),d=k.eagerReducer===a?k.eagerState:a(d,k.action);else{var n={lane:l,action:k.action,eagerReducer:k.eagerReducer,\neagerState:k.eagerState,next:null};null===h?(g=h=n,f=d):h=h.next=n;R.lanes|=l;Dg|=l}k=k.next}while(null!==k&&k!==e);null===h?f=d:h.next=g;He(d,b.memoizedState)||(ug=!0);b.memoizedState=d;b.baseState=f;b.baseQueue=h;c.lastRenderedState=d}return[b.memoizedState,c.dispatch]}\nfunction Lh(a){var b=Ih(),c=b.queue;if(null===c)throw Error(y(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);He(f,b.memoizedState)||(ug=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f}return[f,d]}\nfunction Mh(a,b,c){var d=b._getVersion;d=d(b._source);var e=b._workInProgressVersionPrimary;if(null!==e)a=e===d;else if(a=a.mutableReadLanes,a=(xh&a)===a)b._workInProgressVersionPrimary=d,th.push(b);if(a)return c(b._source);th.push(b);throw Error(y(350));}\nfunction Nh(a,b,c,d){var e=U;if(null===e)throw Error(y(349));var f=b._getVersion,g=f(b._source),h=vh.current,k=h.useState(function(){return Mh(e,b,c)}),l=k[1],n=k[0];k=T;var A=a.memoizedState,p=A.refs,C=p.getSnapshot,x=A.source;A=A.subscribe;var w=R;a.memoizedState={refs:p,source:b,subscribe:d};h.useEffect(function(){p.getSnapshot=c;p.setSnapshot=l;var a=f(b._source);if(!He(g,a)){a=c(b._source);He(n,a)||(l(a),a=Ig(w),e.mutableReadLanes|=a&e.pendingLanes);a=e.mutableReadLanes;e.entangledLanes|=a;for(var d=\ne.entanglements,h=a;0<h;){var k=31-Vc(h),v=1<<k;d[k]|=a;h&=~v}}},[c,b,d]);h.useEffect(function(){return d(b._source,function(){var a=p.getSnapshot,c=p.setSnapshot;try{c(a(b._source));var d=Ig(w);e.mutableReadLanes|=d&e.pendingLanes}catch(q){c(function(){throw q;})}})},[b,d]);He(C,c)&&He(x,b)&&He(A,d)||(a={pending:null,dispatch:null,lastRenderedReducer:Jh,lastRenderedState:n},a.dispatch=l=Oh.bind(null,R,a),k.queue=a,k.baseQueue=null,n=Mh(e,b,c),k.memoizedState=k.baseState=n);return n}\nfunction Ph(a,b,c){var d=Ih();return Nh(d,a,b,c)}function Qh(a){var b=Hh();\"function\"===typeof a&&(a=a());b.memoizedState=b.baseState=a;a=b.queue={pending:null,dispatch:null,lastRenderedReducer:Jh,lastRenderedState:a};a=a.dispatch=Oh.bind(null,R,a);return[b.memoizedState,a]}\nfunction Rh(a,b,c,d){a={tag:a,create:b,destroy:c,deps:d,next:null};b=R.updateQueue;null===b?(b={lastEffect:null},R.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function Sh(a){var b=Hh();a={current:a};return b.memoizedState=a}function Th(){return Ih().memoizedState}function Uh(a,b,c,d){var e=Hh();R.flags|=a;e.memoizedState=Rh(1|b,c,void 0,void 0===d?null:d)}\nfunction Vh(a,b,c,d){var e=Ih();d=void 0===d?null:d;var f=void 0;if(null!==S){var g=S.memoizedState;f=g.destroy;if(null!==d&&Bh(d,g.deps)){Rh(b,c,f,d);return}}R.flags|=a;e.memoizedState=Rh(1|b,c,f,d)}function Wh(a,b){return Uh(516,4,a,b)}function Xh(a,b){return Vh(516,4,a,b)}function Yh(a,b){return Vh(4,2,a,b)}function Zh(a,b){if(\"function\"===typeof b)return a=a(),b(a),function(){b(null)};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null}}\nfunction $h(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return Vh(4,2,Zh.bind(null,b,a),c)}function ai(){}function bi(a,b){var c=Ih();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Bh(b,d[1]))return d[0];c.memoizedState=[a,b];return a}function ci(a,b){var c=Ih();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Bh(b,d[1]))return d[0];a=a();c.memoizedState=[a,b];return a}\nfunction di(a,b){var c=eg();gg(98>c?98:c,function(){a(!0)});gg(97<c?97:c,function(){var c=wh.transition;wh.transition=1;try{a(!1),b()}finally{wh.transition=c}})}\nfunction Oh(a,b,c){var d=Hg(),e=Ig(a),f={lane:e,action:c,eagerReducer:null,eagerState:null,next:null},g=b.pending;null===g?f.next=f:(f.next=g.next,g.next=f);b.pending=f;g=a.alternate;if(a===R||null!==g&&g===R)zh=yh=!0;else{if(0===a.lanes&&(null===g||0===g.lanes)&&(g=b.lastRenderedReducer,null!==g))try{var h=b.lastRenderedState,k=g(h,c);f.eagerReducer=g;f.eagerState=k;if(He(k,h))return}catch(l){}finally{}Jg(a,e,d)}}\nvar Gh={readContext:vg,useCallback:Ah,useContext:Ah,useEffect:Ah,useImperativeHandle:Ah,useLayoutEffect:Ah,useMemo:Ah,useReducer:Ah,useRef:Ah,useState:Ah,useDebugValue:Ah,useDeferredValue:Ah,useTransition:Ah,useMutableSource:Ah,useOpaqueIdentifier:Ah,unstable_isNewReconciler:!1},Dh={readContext:vg,useCallback:function(a,b){Hh().memoizedState=[a,void 0===b?null:b];return a},useContext:vg,useEffect:Wh,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return Uh(4,2,Zh.bind(null,\nb,a),c)},useLayoutEffect:function(a,b){return Uh(4,2,a,b)},useMemo:function(a,b){var c=Hh();b=void 0===b?null:b;a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=Hh();b=void 0!==c?c(b):b;d.memoizedState=d.baseState=b;a=d.queue={pending:null,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};a=a.dispatch=Oh.bind(null,R,a);return[d.memoizedState,a]},useRef:Sh,useState:Qh,useDebugValue:ai,useDeferredValue:function(a){var b=Qh(a),c=b[0],d=b[1];Wh(function(){var b=wh.transition;\nwh.transition=1;try{d(a)}finally{wh.transition=b}},[a]);return c},useTransition:function(){var a=Qh(!1),b=a[0];a=di.bind(null,a[1]);Sh(a);return[a,b]},useMutableSource:function(a,b,c){var d=Hh();d.memoizedState={refs:{getSnapshot:b,setSnapshot:null},source:a,subscribe:c};return Nh(d,a,b,c)},useOpaqueIdentifier:function(){if(lh){var a=!1,b=uf(function(){a||(a=!0,c(\"r:\"+(tf++).toString(36)));throw Error(y(355));}),c=Qh(b)[1];0===(R.mode&2)&&(R.flags|=516,Rh(5,function(){c(\"r:\"+(tf++).toString(36))},\nvoid 0,null));return b}b=\"r:\"+(tf++).toString(36);Qh(b);return b},unstable_isNewReconciler:!1},Eh={readContext:vg,useCallback:bi,useContext:vg,useEffect:Xh,useImperativeHandle:$h,useLayoutEffect:Yh,useMemo:ci,useReducer:Kh,useRef:Th,useState:function(){return Kh(Jh)},useDebugValue:ai,useDeferredValue:function(a){var b=Kh(Jh),c=b[0],d=b[1];Xh(function(){var b=wh.transition;wh.transition=1;try{d(a)}finally{wh.transition=b}},[a]);return c},useTransition:function(){var a=Kh(Jh)[0];return[Th().current,\na]},useMutableSource:Ph,useOpaqueIdentifier:function(){return Kh(Jh)[0]},unstable_isNewReconciler:!1},Fh={readContext:vg,useCallback:bi,useContext:vg,useEffect:Xh,useImperativeHandle:$h,useLayoutEffect:Yh,useMemo:ci,useReducer:Lh,useRef:Th,useState:function(){return Lh(Jh)},useDebugValue:ai,useDeferredValue:function(a){var b=Lh(Jh),c=b[0],d=b[1];Xh(function(){var b=wh.transition;wh.transition=1;try{d(a)}finally{wh.transition=b}},[a]);return c},useTransition:function(){var a=Lh(Jh)[0];return[Th().current,\na]},useMutableSource:Ph,useOpaqueIdentifier:function(){return Lh(Jh)[0]},unstable_isNewReconciler:!1},ei=ra.ReactCurrentOwner,ug=!1;function fi(a,b,c,d){b.child=null===a?Zg(b,null,c,d):Yg(b,a.child,c,d)}function gi(a,b,c,d,e){c=c.render;var f=b.ref;tg(b,e);d=Ch(a,b,c,d,f,e);if(null!==a&&!ug)return b.updateQueue=a.updateQueue,b.flags&=-517,a.lanes&=~e,hi(a,b,e);b.flags|=1;fi(a,b,d,e);return b.child}\nfunction ii(a,b,c,d,e,f){if(null===a){var g=c.type;if(\"function\"===typeof g&&!ji(g)&&void 0===g.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=g,ki(a,b,g,d,e,f);a=Vg(c.type,null,d,b,b.mode,f);a.ref=b.ref;a.return=b;return b.child=a}g=a.child;if(0===(e&f)&&(e=g.memoizedProps,c=c.compare,c=null!==c?c:Je,c(e,d)&&a.ref===b.ref))return hi(a,b,f);b.flags|=1;a=Tg(g,d);a.ref=b.ref;a.return=b;return b.child=a}\nfunction ki(a,b,c,d,e,f){if(null!==a&&Je(a.memoizedProps,d)&&a.ref===b.ref)if(ug=!1,0!==(f&e))0!==(a.flags&16384)&&(ug=!0);else return b.lanes=a.lanes,hi(a,b,f);return li(a,b,c,d,f)}\nfunction mi(a,b,c){var d=b.pendingProps,e=d.children,f=null!==a?a.memoizedState:null;if(\"hidden\"===d.mode||\"unstable-defer-without-hiding\"===d.mode)if(0===(b.mode&4))b.memoizedState={baseLanes:0},ni(b,c);else if(0!==(c&1073741824))b.memoizedState={baseLanes:0},ni(b,null!==f?f.baseLanes:c);else return a=null!==f?f.baseLanes|c:c,b.lanes=b.childLanes=1073741824,b.memoizedState={baseLanes:a},ni(b,a),null;else null!==f?(d=f.baseLanes|c,b.memoizedState=null):d=c,ni(b,d);fi(a,b,e,c);return b.child}\nfunction oi(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=128}function li(a,b,c,d,e){var f=Ff(c)?Df:M.current;f=Ef(b,f);tg(b,e);c=Ch(a,b,c,d,f,e);if(null!==a&&!ug)return b.updateQueue=a.updateQueue,b.flags&=-517,a.lanes&=~e,hi(a,b,e);b.flags|=1;fi(a,b,c,e);return b.child}\nfunction pi(a,b,c,d,e){if(Ff(c)){var f=!0;Jf(b)}else f=!1;tg(b,e);if(null===b.stateNode)null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2),Mg(b,c,d),Og(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var k=g.context,l=c.contextType;\"object\"===typeof l&&null!==l?l=vg(l):(l=Ff(c)?Df:M.current,l=Ef(b,l));var n=c.getDerivedStateFromProps,A=\"function\"===typeof n||\"function\"===typeof g.getSnapshotBeforeUpdate;A||\"function\"!==typeof g.UNSAFE_componentWillReceiveProps&&\n\"function\"!==typeof g.componentWillReceiveProps||(h!==d||k!==l)&&Ng(b,g,d,l);wg=!1;var p=b.memoizedState;g.state=p;Cg(b,d,g,e);k=b.memoizedState;h!==d||p!==k||N.current||wg?(\"function\"===typeof n&&(Gg(b,c,n,d),k=b.memoizedState),(h=wg||Lg(b,c,h,d,p,k,l))?(A||\"function\"!==typeof g.UNSAFE_componentWillMount&&\"function\"!==typeof g.componentWillMount||(\"function\"===typeof g.componentWillMount&&g.componentWillMount(),\"function\"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),\"function\"===\ntypeof g.componentDidMount&&(b.flags|=4)):(\"function\"===typeof g.componentDidMount&&(b.flags|=4),b.memoizedProps=d,b.memoizedState=k),g.props=d,g.state=k,g.context=l,d=h):(\"function\"===typeof g.componentDidMount&&(b.flags|=4),d=!1)}else{g=b.stateNode;yg(a,b);h=b.memoizedProps;l=b.type===b.elementType?h:lg(b.type,h);g.props=l;A=b.pendingProps;p=g.context;k=c.contextType;\"object\"===typeof k&&null!==k?k=vg(k):(k=Ff(c)?Df:M.current,k=Ef(b,k));var C=c.getDerivedStateFromProps;(n=\"function\"===typeof C||\n\"function\"===typeof g.getSnapshotBeforeUpdate)||\"function\"!==typeof g.UNSAFE_componentWillReceiveProps&&\"function\"!==typeof g.componentWillReceiveProps||(h!==A||p!==k)&&Ng(b,g,d,k);wg=!1;p=b.memoizedState;g.state=p;Cg(b,d,g,e);var x=b.memoizedState;h!==A||p!==x||N.current||wg?(\"function\"===typeof C&&(Gg(b,c,C,d),x=b.memoizedState),(l=wg||Lg(b,c,l,d,p,x,k))?(n||\"function\"!==typeof g.UNSAFE_componentWillUpdate&&\"function\"!==typeof g.componentWillUpdate||(\"function\"===typeof g.componentWillUpdate&&g.componentWillUpdate(d,\nx,k),\"function\"===typeof g.UNSAFE_componentWillUpdate&&g.UNSAFE_componentWillUpdate(d,x,k)),\"function\"===typeof g.componentDidUpdate&&(b.flags|=4),\"function\"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=256)):(\"function\"!==typeof g.componentDidUpdate||h===a.memoizedProps&&p===a.memoizedState||(b.flags|=4),\"function\"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&p===a.memoizedState||(b.flags|=256),b.memoizedProps=d,b.memoizedState=x),g.props=d,g.state=x,g.context=k,d=l):(\"function\"!==typeof g.componentDidUpdate||\nh===a.memoizedProps&&p===a.memoizedState||(b.flags|=4),\"function\"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&p===a.memoizedState||(b.flags|=256),d=!1)}return qi(a,b,c,d,f,e)}\nfunction qi(a,b,c,d,e,f){oi(a,b);var g=0!==(b.flags&64);if(!d&&!g)return e&&Kf(b,c,!1),hi(a,b,f);d=b.stateNode;ei.current=b;var h=g&&\"function\"!==typeof c.getDerivedStateFromError?null:d.render();b.flags|=1;null!==a&&g?(b.child=Yg(b,a.child,null,f),b.child=Yg(b,null,h,f)):fi(a,b,h,f);b.memoizedState=d.state;e&&Kf(b,c,!0);return b.child}function ri(a){var b=a.stateNode;b.pendingContext?Hf(a,b.pendingContext,b.pendingContext!==b.context):b.context&&Hf(a,b.context,!1);eh(a,b.containerInfo)}\nvar si={dehydrated:null,retryLane:0};\nfunction ti(a,b,c){var d=b.pendingProps,e=P.current,f=!1,g;(g=0!==(b.flags&64))||(g=null!==a&&null===a.memoizedState?!1:0!==(e&2));g?(f=!0,b.flags&=-65):null!==a&&null===a.memoizedState||void 0===d.fallback||!0===d.unstable_avoidThisFallback||(e|=1);I(P,e&1);if(null===a){void 0!==d.fallback&&ph(b);a=d.children;e=d.fallback;if(f)return a=ui(b,a,e,c),b.child.memoizedState={baseLanes:c},b.memoizedState=si,a;if(\"number\"===typeof d.unstable_expectedLoadTime)return a=ui(b,a,e,c),b.child.memoizedState={baseLanes:c},\nb.memoizedState=si,b.lanes=33554432,a;c=vi({mode:\"visible\",children:a},b.mode,c,null);c.return=b;return b.child=c}if(null!==a.memoizedState){if(f)return d=wi(a,b,d.children,d.fallback,c),f=b.child,e=a.child.memoizedState,f.memoizedState=null===e?{baseLanes:c}:{baseLanes:e.baseLanes|c},f.childLanes=a.childLanes&~c,b.memoizedState=si,d;c=xi(a,b,d.children,c);b.memoizedState=null;return c}if(f)return d=wi(a,b,d.children,d.fallback,c),f=b.child,e=a.child.memoizedState,f.memoizedState=null===e?{baseLanes:c}:\n{baseLanes:e.baseLanes|c},f.childLanes=a.childLanes&~c,b.memoizedState=si,d;c=xi(a,b,d.children,c);b.memoizedState=null;return c}function ui(a,b,c,d){var e=a.mode,f=a.child;b={mode:\"hidden\",children:b};0===(e&2)&&null!==f?(f.childLanes=0,f.pendingProps=b):f=vi(b,e,0,null);c=Xg(c,e,d,null);f.return=a;c.return=a;f.sibling=c;a.child=f;return c}\nfunction xi(a,b,c,d){var e=a.child;a=e.sibling;c=Tg(e,{mode:\"visible\",children:c});0===(b.mode&2)&&(c.lanes=d);c.return=b;c.sibling=null;null!==a&&(a.nextEffect=null,a.flags=8,b.firstEffect=b.lastEffect=a);return b.child=c}\nfunction wi(a,b,c,d,e){var f=b.mode,g=a.child;a=g.sibling;var h={mode:\"hidden\",children:c};0===(f&2)&&b.child!==g?(c=b.child,c.childLanes=0,c.pendingProps=h,g=c.lastEffect,null!==g?(b.firstEffect=c.firstEffect,b.lastEffect=g,g.nextEffect=null):b.firstEffect=b.lastEffect=null):c=Tg(g,h);null!==a?d=Tg(a,d):(d=Xg(d,f,e,null),d.flags|=2);d.return=b;c.return=b;c.sibling=d;b.child=c;return d}function yi(a,b){a.lanes|=b;var c=a.alternate;null!==c&&(c.lanes|=b);sg(a.return,b)}\nfunction zi(a,b,c,d,e,f){var g=a.memoizedState;null===g?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e,lastEffect:f}:(g.isBackwards=b,g.rendering=null,g.renderingStartTime=0,g.last=d,g.tail=c,g.tailMode=e,g.lastEffect=f)}\nfunction Ai(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;fi(a,b,d.children,c);d=P.current;if(0!==(d&2))d=d&1|2,b.flags|=64;else{if(null!==a&&0!==(a.flags&64))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&yi(a,c);else if(19===a.tag)yi(a,c);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return}a.sibling.return=a.return;a=a.sibling}d&=1}I(P,d);if(0===(b.mode&2))b.memoizedState=\nnull;else switch(e){case \"forwards\":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===ih(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);zi(b,!1,e,c,f,b.lastEffect);break;case \"backwards\":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===ih(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a}zi(b,!0,c,null,f,b.lastEffect);break;case \"together\":zi(b,!1,null,null,void 0,b.lastEffect);break;default:b.memoizedState=null}return b.child}\nfunction hi(a,b,c){null!==a&&(b.dependencies=a.dependencies);Dg|=b.lanes;if(0!==(c&b.childLanes)){if(null!==a&&b.child!==a.child)throw Error(y(153));if(null!==b.child){a=b.child;c=Tg(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=Tg(a,a.pendingProps),c.return=b;c.sibling=null}return b.child}return null}var Bi,Ci,Di,Ei;\nBi=function(a,b){for(var c=b.child;null!==c;){if(5===c.tag||6===c.tag)a.appendChild(c.stateNode);else if(4!==c.tag&&null!==c.child){c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;){if(null===c.return||c.return===b)return;c=c.return}c.sibling.return=c.return;c=c.sibling}};Ci=function(){};\nDi=function(a,b,c,d){var e=a.memoizedProps;if(e!==d){a=b.stateNode;dh(ah.current);var f=null;switch(c){case \"input\":e=Ya(a,e);d=Ya(a,d);f=[];break;case \"option\":e=eb(a,e);d=eb(a,d);f=[];break;case \"select\":e=m({},e,{value:void 0});d=m({},d,{value:void 0});f=[];break;case \"textarea\":e=gb(a,e);d=gb(a,d);f=[];break;default:\"function\"!==typeof e.onClick&&\"function\"===typeof d.onClick&&(a.onclick=jf)}vb(c,d);var g;c=null;for(l in e)if(!d.hasOwnProperty(l)&&e.hasOwnProperty(l)&&null!=e[l])if(\"style\"===\nl){var h=e[l];for(g in h)h.hasOwnProperty(g)&&(c||(c={}),c[g]=\"\")}else\"dangerouslySetInnerHTML\"!==l&&\"children\"!==l&&\"suppressContentEditableWarning\"!==l&&\"suppressHydrationWarning\"!==l&&\"autoFocus\"!==l&&(ca.hasOwnProperty(l)?f||(f=[]):(f=f||[]).push(l,null));for(l in d){var k=d[l];h=null!=e?e[l]:void 0;if(d.hasOwnProperty(l)&&k!==h&&(null!=k||null!=h))if(\"style\"===l)if(h){for(g in h)!h.hasOwnProperty(g)||k&&k.hasOwnProperty(g)||(c||(c={}),c[g]=\"\");for(g in k)k.hasOwnProperty(g)&&h[g]!==k[g]&&(c||\n(c={}),c[g]=k[g])}else c||(f||(f=[]),f.push(l,c)),c=k;else\"dangerouslySetInnerHTML\"===l?(k=k?k.__html:void 0,h=h?h.__html:void 0,null!=k&&h!==k&&(f=f||[]).push(l,k)):\"children\"===l?\"string\"!==typeof k&&\"number\"!==typeof k||(f=f||[]).push(l,\"\"+k):\"suppressContentEditableWarning\"!==l&&\"suppressHydrationWarning\"!==l&&(ca.hasOwnProperty(l)?(null!=k&&\"onScroll\"===l&&G(\"scroll\",a),f||h===k||(f=[])):\"object\"===typeof k&&null!==k&&k.$$typeof===Ga?k.toString():(f=f||[]).push(l,k))}c&&(f=f||[]).push(\"style\",\nc);var l=f;if(b.updateQueue=l)b.flags|=4}};Ei=function(a,b,c,d){c!==d&&(b.flags|=4)};function Fi(a,b){if(!lh)switch(a.tailMode){case \"hidden\":b=a.tail;for(var c=null;null!==b;)null!==b.alternate&&(c=b),b=b.sibling;null===c?a.tail=null:c.sibling=null;break;case \"collapsed\":c=a.tail;for(var d=null;null!==c;)null!==c.alternate&&(d=c),c=c.sibling;null===d?b||null===a.tail?a.tail=null:a.tail.sibling=null:d.sibling=null}}\nfunction Gi(a,b,c){var d=b.pendingProps;switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return null;case 1:return Ff(b.type)&&Gf(),null;case 3:fh();H(N);H(M);uh();d=b.stateNode;d.pendingContext&&(d.context=d.pendingContext,d.pendingContext=null);if(null===a||null===a.child)rh(b)?b.flags|=4:d.hydrate||(b.flags|=256);Ci(b);return null;case 5:hh(b);var e=dh(ch.current);c=b.type;if(null!==a&&null!=b.stateNode)Di(a,b,c,d,e),a.ref!==b.ref&&(b.flags|=128);else{if(!d){if(null===\nb.stateNode)throw Error(y(166));return null}a=dh(ah.current);if(rh(b)){d=b.stateNode;c=b.type;var f=b.memoizedProps;d[wf]=b;d[xf]=f;switch(c){case \"dialog\":G(\"cancel\",d);G(\"close\",d);break;case \"iframe\":case \"object\":case \"embed\":G(\"load\",d);break;case \"video\":case \"audio\":for(a=0;a<Xe.length;a++)G(Xe[a],d);break;case \"source\":G(\"error\",d);break;case \"img\":case \"image\":case \"link\":G(\"error\",d);G(\"load\",d);break;case \"details\":G(\"toggle\",d);break;case \"input\":Za(d,f);G(\"invalid\",d);break;case \"select\":d._wrapperState=\n{wasMultiple:!!f.multiple};G(\"invalid\",d);break;case \"textarea\":hb(d,f),G(\"invalid\",d)}vb(c,f);a=null;for(var g in f)f.hasOwnProperty(g)&&(e=f[g],\"children\"===g?\"string\"===typeof e?d.textContent!==e&&(a=[\"children\",e]):\"number\"===typeof e&&d.textContent!==\"\"+e&&(a=[\"children\",\"\"+e]):ca.hasOwnProperty(g)&&null!=e&&\"onScroll\"===g&&G(\"scroll\",d));switch(c){case \"input\":Va(d);cb(d,f,!0);break;case \"textarea\":Va(d);jb(d);break;case \"select\":case \"option\":break;default:\"function\"===typeof f.onClick&&(d.onclick=\njf)}d=a;b.updateQueue=d;null!==d&&(b.flags|=4)}else{g=9===e.nodeType?e:e.ownerDocument;a===kb.html&&(a=lb(c));a===kb.html?\"script\"===c?(a=g.createElement(\"div\"),a.innerHTML=\"<script>\\x3c/script>\",a=a.removeChild(a.firstChild)):\"string\"===typeof d.is?a=g.createElement(c,{is:d.is}):(a=g.createElement(c),\"select\"===c&&(g=a,d.multiple?g.multiple=!0:d.size&&(g.size=d.size))):a=g.createElementNS(a,c);a[wf]=b;a[xf]=d;Bi(a,b,!1,!1);b.stateNode=a;g=wb(c,d);switch(c){case \"dialog\":G(\"cancel\",a);G(\"close\",a);\ne=d;break;case \"iframe\":case \"object\":case \"embed\":G(\"load\",a);e=d;break;case \"video\":case \"audio\":for(e=0;e<Xe.length;e++)G(Xe[e],a);e=d;break;case \"source\":G(\"error\",a);e=d;break;case \"img\":case \"image\":case \"link\":G(\"error\",a);G(\"load\",a);e=d;break;case \"details\":G(\"toggle\",a);e=d;break;case \"input\":Za(a,d);e=Ya(a,d);G(\"invalid\",a);break;case \"option\":e=eb(a,d);break;case \"select\":a._wrapperState={wasMultiple:!!d.multiple};e=m({},d,{value:void 0});G(\"invalid\",a);break;case \"textarea\":hb(a,d);e=\ngb(a,d);G(\"invalid\",a);break;default:e=d}vb(c,e);var h=e;for(f in h)if(h.hasOwnProperty(f)){var k=h[f];\"style\"===f?tb(a,k):\"dangerouslySetInnerHTML\"===f?(k=k?k.__html:void 0,null!=k&&ob(a,k)):\"children\"===f?\"string\"===typeof k?(\"textarea\"!==c||\"\"!==k)&&pb(a,k):\"number\"===typeof k&&pb(a,\"\"+k):\"suppressContentEditableWarning\"!==f&&\"suppressHydrationWarning\"!==f&&\"autoFocus\"!==f&&(ca.hasOwnProperty(f)?null!=k&&\"onScroll\"===f&&G(\"scroll\",a):null!=k&&qa(a,f,k,g))}switch(c){case \"input\":Va(a);cb(a,d,!1);\nbreak;case \"textarea\":Va(a);jb(a);break;case \"option\":null!=d.value&&a.setAttribute(\"value\",\"\"+Sa(d.value));break;case \"select\":a.multiple=!!d.multiple;f=d.value;null!=f?fb(a,!!d.multiple,f,!1):null!=d.defaultValue&&fb(a,!!d.multiple,d.defaultValue,!0);break;default:\"function\"===typeof e.onClick&&(a.onclick=jf)}mf(c,d)&&(b.flags|=4)}null!==b.ref&&(b.flags|=128)}return null;case 6:if(a&&null!=b.stateNode)Ei(a,b,a.memoizedProps,d);else{if(\"string\"!==typeof d&&null===b.stateNode)throw Error(y(166));\nc=dh(ch.current);dh(ah.current);rh(b)?(d=b.stateNode,c=b.memoizedProps,d[wf]=b,d.nodeValue!==c&&(b.flags|=4)):(d=(9===c.nodeType?c:c.ownerDocument).createTextNode(d),d[wf]=b,b.stateNode=d)}return null;case 13:H(P);d=b.memoizedState;if(0!==(b.flags&64))return b.lanes=c,b;d=null!==d;c=!1;null===a?void 0!==b.memoizedProps.fallback&&rh(b):c=null!==a.memoizedState;if(d&&!c&&0!==(b.mode&2))if(null===a&&!0!==b.memoizedProps.unstable_avoidThisFallback||0!==(P.current&1))0===V&&(V=3);else{if(0===V||3===V)V=\n4;null===U||0===(Dg&134217727)&&0===(Hi&134217727)||Ii(U,W)}if(d||c)b.flags|=4;return null;case 4:return fh(),Ci(b),null===a&&cf(b.stateNode.containerInfo),null;case 10:return rg(b),null;case 17:return Ff(b.type)&&Gf(),null;case 19:H(P);d=b.memoizedState;if(null===d)return null;f=0!==(b.flags&64);g=d.rendering;if(null===g)if(f)Fi(d,!1);else{if(0!==V||null!==a&&0!==(a.flags&64))for(a=b.child;null!==a;){g=ih(a);if(null!==g){b.flags|=64;Fi(d,!1);f=g.updateQueue;null!==f&&(b.updateQueue=f,b.flags|=4);\nnull===d.lastEffect&&(b.firstEffect=null);b.lastEffect=d.lastEffect;d=c;for(c=b.child;null!==c;)f=c,a=d,f.flags&=2,f.nextEffect=null,f.firstEffect=null,f.lastEffect=null,g=f.alternate,null===g?(f.childLanes=0,f.lanes=a,f.child=null,f.memoizedProps=null,f.memoizedState=null,f.updateQueue=null,f.dependencies=null,f.stateNode=null):(f.childLanes=g.childLanes,f.lanes=g.lanes,f.child=g.child,f.memoizedProps=g.memoizedProps,f.memoizedState=g.memoizedState,f.updateQueue=g.updateQueue,f.type=g.type,a=g.dependencies,\nf.dependencies=null===a?null:{lanes:a.lanes,firstContext:a.firstContext}),c=c.sibling;I(P,P.current&1|2);return b.child}a=a.sibling}null!==d.tail&&O()>Ji&&(b.flags|=64,f=!0,Fi(d,!1),b.lanes=33554432)}else{if(!f)if(a=ih(g),null!==a){if(b.flags|=64,f=!0,c=a.updateQueue,null!==c&&(b.updateQueue=c,b.flags|=4),Fi(d,!0),null===d.tail&&\"hidden\"===d.tailMode&&!g.alternate&&!lh)return b=b.lastEffect=d.lastEffect,null!==b&&(b.nextEffect=null),null}else 2*O()-d.renderingStartTime>Ji&&1073741824!==c&&(b.flags|=\n64,f=!0,Fi(d,!1),b.lanes=33554432);d.isBackwards?(g.sibling=b.child,b.child=g):(c=d.last,null!==c?c.sibling=g:b.child=g,d.last=g)}return null!==d.tail?(c=d.tail,d.rendering=c,d.tail=c.sibling,d.lastEffect=b.lastEffect,d.renderingStartTime=O(),c.sibling=null,b=P.current,I(P,f?b&1|2:b&1),c):null;case 23:case 24:return Ki(),null!==a&&null!==a.memoizedState!==(null!==b.memoizedState)&&\"unstable-defer-without-hiding\"!==d.mode&&(b.flags|=4),null}throw Error(y(156,b.tag));}\nfunction Li(a){switch(a.tag){case 1:Ff(a.type)&&Gf();var b=a.flags;return b&4096?(a.flags=b&-4097|64,a):null;case 3:fh();H(N);H(M);uh();b=a.flags;if(0!==(b&64))throw Error(y(285));a.flags=b&-4097|64;return a;case 5:return hh(a),null;case 13:return H(P),b=a.flags,b&4096?(a.flags=b&-4097|64,a):null;case 19:return H(P),null;case 4:return fh(),null;case 10:return rg(a),null;case 23:case 24:return Ki(),null;default:return null}}\nfunction Mi(a,b){try{var c=\"\",d=b;do c+=Qa(d),d=d.return;while(d);var e=c}catch(f){e=\"\\nError generating stack: \"+f.message+\"\\n\"+f.stack}return{value:a,source:b,stack:e}}function Ni(a,b){try{console.error(b.value)}catch(c){setTimeout(function(){throw c;})}}var Oi=\"function\"===typeof WeakMap?WeakMap:Map;function Pi(a,b,c){c=zg(-1,c);c.tag=3;c.payload={element:null};var d=b.value;c.callback=function(){Qi||(Qi=!0,Ri=d);Ni(a,b)};return c}\nfunction Si(a,b,c){c=zg(-1,c);c.tag=3;var d=a.type.getDerivedStateFromError;if(\"function\"===typeof d){var e=b.value;c.payload=function(){Ni(a,b);return d(e)}}var f=a.stateNode;null!==f&&\"function\"===typeof f.componentDidCatch&&(c.callback=function(){\"function\"!==typeof d&&(null===Ti?Ti=new Set([this]):Ti.add(this),Ni(a,b));var c=b.stack;this.componentDidCatch(b.value,{componentStack:null!==c?c:\"\"})});return c}var Ui=\"function\"===typeof WeakSet?WeakSet:Set;\nfunction Vi(a){var b=a.ref;if(null!==b)if(\"function\"===typeof b)try{b(null)}catch(c){Wi(a,c)}else b.current=null}function Xi(a,b){switch(b.tag){case 0:case 11:case 15:case 22:return;case 1:if(b.flags&256&&null!==a){var c=a.memoizedProps,d=a.memoizedState;a=b.stateNode;b=a.getSnapshotBeforeUpdate(b.elementType===b.type?c:lg(b.type,c),d);a.__reactInternalSnapshotBeforeUpdate=b}return;case 3:b.flags&256&&qf(b.stateNode.containerInfo);return;case 5:case 6:case 4:case 17:return}throw Error(y(163));}\nfunction Yi(a,b,c){switch(c.tag){case 0:case 11:case 15:case 22:b=c.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){a=b=b.next;do{if(3===(a.tag&3)){var d=a.create;a.destroy=d()}a=a.next}while(a!==b)}b=c.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){a=b=b.next;do{var e=a;d=e.next;e=e.tag;0!==(e&4)&&0!==(e&1)&&(Zi(c,a),$i(c,a));a=d}while(a!==b)}return;case 1:a=c.stateNode;c.flags&4&&(null===b?a.componentDidMount():(d=c.elementType===c.type?b.memoizedProps:lg(c.type,b.memoizedProps),a.componentDidUpdate(d,\nb.memoizedState,a.__reactInternalSnapshotBeforeUpdate)));b=c.updateQueue;null!==b&&Eg(c,b,a);return;case 3:b=c.updateQueue;if(null!==b){a=null;if(null!==c.child)switch(c.child.tag){case 5:a=c.child.stateNode;break;case 1:a=c.child.stateNode}Eg(c,b,a)}return;case 5:a=c.stateNode;null===b&&c.flags&4&&mf(c.type,c.memoizedProps)&&a.focus();return;case 6:return;case 4:return;case 12:return;case 13:null===c.memoizedState&&(c=c.alternate,null!==c&&(c=c.memoizedState,null!==c&&(c=c.dehydrated,null!==c&&Cc(c))));\nreturn;case 19:case 17:case 20:case 21:case 23:case 24:return}throw Error(y(163));}\nfunction aj(a,b){for(var c=a;;){if(5===c.tag){var d=c.stateNode;if(b)d=d.style,\"function\"===typeof d.setProperty?d.setProperty(\"display\",\"none\",\"important\"):d.display=\"none\";else{d=c.stateNode;var e=c.memoizedProps.style;e=void 0!==e&&null!==e&&e.hasOwnProperty(\"display\")?e.display:null;d.style.display=sb(\"display\",e)}}else if(6===c.tag)c.stateNode.nodeValue=b?\"\":c.memoizedProps;else if((23!==c.tag&&24!==c.tag||null===c.memoizedState||c===a)&&null!==c.child){c.child.return=c;c=c.child;continue}if(c===\na)break;for(;null===c.sibling;){if(null===c.return||c.return===a)return;c=c.return}c.sibling.return=c.return;c=c.sibling}}\nfunction bj(a,b){if(Mf&&\"function\"===typeof Mf.onCommitFiberUnmount)try{Mf.onCommitFiberUnmount(Lf,b)}catch(f){}switch(b.tag){case 0:case 11:case 14:case 15:case 22:a=b.updateQueue;if(null!==a&&(a=a.lastEffect,null!==a)){var c=a=a.next;do{var d=c,e=d.destroy;d=d.tag;if(void 0!==e)if(0!==(d&4))Zi(b,c);else{d=b;try{e()}catch(f){Wi(d,f)}}c=c.next}while(c!==a)}break;case 1:Vi(b);a=b.stateNode;if(\"function\"===typeof a.componentWillUnmount)try{a.props=b.memoizedProps,a.state=b.memoizedState,a.componentWillUnmount()}catch(f){Wi(b,\nf)}break;case 5:Vi(b);break;case 4:cj(a,b)}}function dj(a){a.alternate=null;a.child=null;a.dependencies=null;a.firstEffect=null;a.lastEffect=null;a.memoizedProps=null;a.memoizedState=null;a.pendingProps=null;a.return=null;a.updateQueue=null}function ej(a){return 5===a.tag||3===a.tag||4===a.tag}\nfunction fj(a){a:{for(var b=a.return;null!==b;){if(ej(b))break a;b=b.return}throw Error(y(160));}var c=b;b=c.stateNode;switch(c.tag){case 5:var d=!1;break;case 3:b=b.containerInfo;d=!0;break;case 4:b=b.containerInfo;d=!0;break;default:throw Error(y(161));}c.flags&16&&(pb(b,\"\"),c.flags&=-17);a:b:for(c=a;;){for(;null===c.sibling;){if(null===c.return||ej(c.return)){c=null;break a}c=c.return}c.sibling.return=c.return;for(c=c.sibling;5!==c.tag&&6!==c.tag&&18!==c.tag;){if(c.flags&2)continue b;if(null===\nc.child||4===c.tag)continue b;else c.child.return=c,c=c.child}if(!(c.flags&2)){c=c.stateNode;break a}}d?gj(a,c,b):hj(a,c,b)}\nfunction gj(a,b,c){var d=a.tag,e=5===d||6===d;if(e)a=e?a.stateNode:a.stateNode.instance,b?8===c.nodeType?c.parentNode.insertBefore(a,b):c.insertBefore(a,b):(8===c.nodeType?(b=c.parentNode,b.insertBefore(a,c)):(b=c,b.appendChild(a)),c=c._reactRootContainer,null!==c&&void 0!==c||null!==b.onclick||(b.onclick=jf));else if(4!==d&&(a=a.child,null!==a))for(gj(a,b,c),a=a.sibling;null!==a;)gj(a,b,c),a=a.sibling}\nfunction hj(a,b,c){var d=a.tag,e=5===d||6===d;if(e)a=e?a.stateNode:a.stateNode.instance,b?c.insertBefore(a,b):c.appendChild(a);else if(4!==d&&(a=a.child,null!==a))for(hj(a,b,c),a=a.sibling;null!==a;)hj(a,b,c),a=a.sibling}\nfunction cj(a,b){for(var c=b,d=!1,e,f;;){if(!d){d=c.return;a:for(;;){if(null===d)throw Error(y(160));e=d.stateNode;switch(d.tag){case 5:f=!1;break a;case 3:e=e.containerInfo;f=!0;break a;case 4:e=e.containerInfo;f=!0;break a}d=d.return}d=!0}if(5===c.tag||6===c.tag){a:for(var g=a,h=c,k=h;;)if(bj(g,k),null!==k.child&&4!==k.tag)k.child.return=k,k=k.child;else{if(k===h)break a;for(;null===k.sibling;){if(null===k.return||k.return===h)break a;k=k.return}k.sibling.return=k.return;k=k.sibling}f?(g=e,h=c.stateNode,\n8===g.nodeType?g.parentNode.removeChild(h):g.removeChild(h)):e.removeChild(c.stateNode)}else if(4===c.tag){if(null!==c.child){e=c.stateNode.containerInfo;f=!0;c.child.return=c;c=c.child;continue}}else if(bj(a,c),null!==c.child){c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;){if(null===c.return||c.return===b)return;c=c.return;4===c.tag&&(d=!1)}c.sibling.return=c.return;c=c.sibling}}\nfunction ij(a,b){switch(b.tag){case 0:case 11:case 14:case 15:case 22:var c=b.updateQueue;c=null!==c?c.lastEffect:null;if(null!==c){var d=c=c.next;do 3===(d.tag&3)&&(a=d.destroy,d.destroy=void 0,void 0!==a&&a()),d=d.next;while(d!==c)}return;case 1:return;case 5:c=b.stateNode;if(null!=c){d=b.memoizedProps;var e=null!==a?a.memoizedProps:d;a=b.type;var f=b.updateQueue;b.updateQueue=null;if(null!==f){c[xf]=d;\"input\"===a&&\"radio\"===d.type&&null!=d.name&&$a(c,d);wb(a,e);b=wb(a,d);for(e=0;e<f.length;e+=\n2){var g=f[e],h=f[e+1];\"style\"===g?tb(c,h):\"dangerouslySetInnerHTML\"===g?ob(c,h):\"children\"===g?pb(c,h):qa(c,g,h,b)}switch(a){case \"input\":ab(c,d);break;case \"textarea\":ib(c,d);break;case \"select\":a=c._wrapperState.wasMultiple,c._wrapperState.wasMultiple=!!d.multiple,f=d.value,null!=f?fb(c,!!d.multiple,f,!1):a!==!!d.multiple&&(null!=d.defaultValue?fb(c,!!d.multiple,d.defaultValue,!0):fb(c,!!d.multiple,d.multiple?[]:\"\",!1))}}}return;case 6:if(null===b.stateNode)throw Error(y(162));b.stateNode.nodeValue=\nb.memoizedProps;return;case 3:c=b.stateNode;c.hydrate&&(c.hydrate=!1,Cc(c.containerInfo));return;case 12:return;case 13:null!==b.memoizedState&&(jj=O(),aj(b.child,!0));kj(b);return;case 19:kj(b);return;case 17:return;case 23:case 24:aj(b,null!==b.memoizedState);return}throw Error(y(163));}function kj(a){var b=a.updateQueue;if(null!==b){a.updateQueue=null;var c=a.stateNode;null===c&&(c=a.stateNode=new Ui);b.forEach(function(b){var d=lj.bind(null,a,b);c.has(b)||(c.add(b),b.then(d,d))})}}\nfunction mj(a,b){return null!==a&&(a=a.memoizedState,null===a||null!==a.dehydrated)?(b=b.memoizedState,null!==b&&null===b.dehydrated):!1}var nj=Math.ceil,oj=ra.ReactCurrentDispatcher,pj=ra.ReactCurrentOwner,X=0,U=null,Y=null,W=0,qj=0,rj=Bf(0),V=0,sj=null,tj=0,Dg=0,Hi=0,uj=0,vj=null,jj=0,Ji=Infinity;function wj(){Ji=O()+500}var Z=null,Qi=!1,Ri=null,Ti=null,xj=!1,yj=null,zj=90,Aj=[],Bj=[],Cj=null,Dj=0,Ej=null,Fj=-1,Gj=0,Hj=0,Ij=null,Jj=!1;function Hg(){return 0!==(X&48)?O():-1!==Fj?Fj:Fj=O()}\nfunction Ig(a){a=a.mode;if(0===(a&2))return 1;if(0===(a&4))return 99===eg()?1:2;0===Gj&&(Gj=tj);if(0!==kg.transition){0!==Hj&&(Hj=null!==vj?vj.pendingLanes:0);a=Gj;var b=4186112&~Hj;b&=-b;0===b&&(a=4186112&~a,b=a&-a,0===b&&(b=8192));return b}a=eg();0!==(X&4)&&98===a?a=Xc(12,Gj):(a=Sc(a),a=Xc(a,Gj));return a}\nfunction Jg(a,b,c){if(50<Dj)throw Dj=0,Ej=null,Error(y(185));a=Kj(a,b);if(null===a)return null;$c(a,b,c);a===U&&(Hi|=b,4===V&&Ii(a,W));var d=eg();1===b?0!==(X&8)&&0===(X&48)?Lj(a):(Mj(a,c),0===X&&(wj(),ig())):(0===(X&4)||98!==d&&99!==d||(null===Cj?Cj=new Set([a]):Cj.add(a)),Mj(a,c));vj=a}function Kj(a,b){a.lanes|=b;var c=a.alternate;null!==c&&(c.lanes|=b);c=a;for(a=a.return;null!==a;)a.childLanes|=b,c=a.alternate,null!==c&&(c.childLanes|=b),c=a,a=a.return;return 3===c.tag?c.stateNode:null}\nfunction Mj(a,b){for(var c=a.callbackNode,d=a.suspendedLanes,e=a.pingedLanes,f=a.expirationTimes,g=a.pendingLanes;0<g;){var h=31-Vc(g),k=1<<h,l=f[h];if(-1===l){if(0===(k&d)||0!==(k&e)){l=b;Rc(k);var n=F;f[h]=10<=n?l+250:6<=n?l+5E3:-1}}else l<=b&&(a.expiredLanes|=k);g&=~k}d=Uc(a,a===U?W:0);b=F;if(0===d)null!==c&&(c!==Zf&&Pf(c),a.callbackNode=null,a.callbackPriority=0);else{if(null!==c){if(a.callbackPriority===b)return;c!==Zf&&Pf(c)}15===b?(c=Lj.bind(null,a),null===ag?(ag=[c],bg=Of(Uf,jg)):ag.push(c),\nc=Zf):14===b?c=hg(99,Lj.bind(null,a)):(c=Tc(b),c=hg(c,Nj.bind(null,a)));a.callbackPriority=b;a.callbackNode=c}}\nfunction Nj(a){Fj=-1;Hj=Gj=0;if(0!==(X&48))throw Error(y(327));var b=a.callbackNode;if(Oj()&&a.callbackNode!==b)return null;var c=Uc(a,a===U?W:0);if(0===c)return null;var d=c;var e=X;X|=16;var f=Pj();if(U!==a||W!==d)wj(),Qj(a,d);do try{Rj();break}catch(h){Sj(a,h)}while(1);qg();oj.current=f;X=e;null!==Y?d=0:(U=null,W=0,d=V);if(0!==(tj&Hi))Qj(a,0);else if(0!==d){2===d&&(X|=64,a.hydrate&&(a.hydrate=!1,qf(a.containerInfo)),c=Wc(a),0!==c&&(d=Tj(a,c)));if(1===d)throw b=sj,Qj(a,0),Ii(a,c),Mj(a,O()),b;a.finishedWork=\na.current.alternate;a.finishedLanes=c;switch(d){case 0:case 1:throw Error(y(345));case 2:Uj(a);break;case 3:Ii(a,c);if((c&62914560)===c&&(d=jj+500-O(),10<d)){if(0!==Uc(a,0))break;e=a.suspendedLanes;if((e&c)!==c){Hg();a.pingedLanes|=a.suspendedLanes&e;break}a.timeoutHandle=of(Uj.bind(null,a),d);break}Uj(a);break;case 4:Ii(a,c);if((c&4186112)===c)break;d=a.eventTimes;for(e=-1;0<c;){var g=31-Vc(c);f=1<<g;g=d[g];g>e&&(e=g);c&=~f}c=e;c=O()-c;c=(120>c?120:480>c?480:1080>c?1080:1920>c?1920:3E3>c?3E3:4320>\nc?4320:1960*nj(c/1960))-c;if(10<c){a.timeoutHandle=of(Uj.bind(null,a),c);break}Uj(a);break;case 5:Uj(a);break;default:throw Error(y(329));}}Mj(a,O());return a.callbackNode===b?Nj.bind(null,a):null}function Ii(a,b){b&=~uj;b&=~Hi;a.suspendedLanes|=b;a.pingedLanes&=~b;for(a=a.expirationTimes;0<b;){var c=31-Vc(b),d=1<<c;a[c]=-1;b&=~d}}\nfunction Lj(a){if(0!==(X&48))throw Error(y(327));Oj();if(a===U&&0!==(a.expiredLanes&W)){var b=W;var c=Tj(a,b);0!==(tj&Hi)&&(b=Uc(a,b),c=Tj(a,b))}else b=Uc(a,0),c=Tj(a,b);0!==a.tag&&2===c&&(X|=64,a.hydrate&&(a.hydrate=!1,qf(a.containerInfo)),b=Wc(a),0!==b&&(c=Tj(a,b)));if(1===c)throw c=sj,Qj(a,0),Ii(a,b),Mj(a,O()),c;a.finishedWork=a.current.alternate;a.finishedLanes=b;Uj(a);Mj(a,O());return null}\nfunction Vj(){if(null!==Cj){var a=Cj;Cj=null;a.forEach(function(a){a.expiredLanes|=24&a.pendingLanes;Mj(a,O())})}ig()}function Wj(a,b){var c=X;X|=1;try{return a(b)}finally{X=c,0===X&&(wj(),ig())}}function Xj(a,b){var c=X;X&=-2;X|=8;try{return a(b)}finally{X=c,0===X&&(wj(),ig())}}function ni(a,b){I(rj,qj);qj|=b;tj|=b}function Ki(){qj=rj.current;H(rj)}\nfunction Qj(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,pf(c));if(null!==Y)for(c=Y.return;null!==c;){var d=c;switch(d.tag){case 1:d=d.type.childContextTypes;null!==d&&void 0!==d&&Gf();break;case 3:fh();H(N);H(M);uh();break;case 5:hh(d);break;case 4:fh();break;case 13:H(P);break;case 19:H(P);break;case 10:rg(d);break;case 23:case 24:Ki()}c=c.return}U=a;Y=Tg(a.current,null);W=qj=tj=b;V=0;sj=null;uj=Hi=Dg=0}\nfunction Sj(a,b){do{var c=Y;try{qg();vh.current=Gh;if(yh){for(var d=R.memoizedState;null!==d;){var e=d.queue;null!==e&&(e.pending=null);d=d.next}yh=!1}xh=0;T=S=R=null;zh=!1;pj.current=null;if(null===c||null===c.return){V=1;sj=b;Y=null;break}a:{var f=a,g=c.return,h=c,k=b;b=W;h.flags|=2048;h.firstEffect=h.lastEffect=null;if(null!==k&&\"object\"===typeof k&&\"function\"===typeof k.then){var l=k;if(0===(h.mode&2)){var n=h.alternate;n?(h.updateQueue=n.updateQueue,h.memoizedState=n.memoizedState,h.lanes=n.lanes):\n(h.updateQueue=null,h.memoizedState=null)}var A=0!==(P.current&1),p=g;do{var C;if(C=13===p.tag){var x=p.memoizedState;if(null!==x)C=null!==x.dehydrated?!0:!1;else{var w=p.memoizedProps;C=void 0===w.fallback?!1:!0!==w.unstable_avoidThisFallback?!0:A?!1:!0}}if(C){var z=p.updateQueue;if(null===z){var u=new Set;u.add(l);p.updateQueue=u}else z.add(l);if(0===(p.mode&2)){p.flags|=64;h.flags|=16384;h.flags&=-2981;if(1===h.tag)if(null===h.alternate)h.tag=17;else{var t=zg(-1,1);t.tag=2;Ag(h,t)}h.lanes|=1;break a}k=\nvoid 0;h=b;var q=f.pingCache;null===q?(q=f.pingCache=new Oi,k=new Set,q.set(l,k)):(k=q.get(l),void 0===k&&(k=new Set,q.set(l,k)));if(!k.has(h)){k.add(h);var v=Yj.bind(null,f,l,h);l.then(v,v)}p.flags|=4096;p.lanes=b;break a}p=p.return}while(null!==p);k=Error((Ra(h.type)||\"A React component\")+\" suspended while rendering, but no fallback UI was specified.\\n\\nAdd a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display.\")}5!==V&&(V=2);k=Mi(k,h);p=\ng;do{switch(p.tag){case 3:f=k;p.flags|=4096;b&=-b;p.lanes|=b;var J=Pi(p,f,b);Bg(p,J);break a;case 1:f=k;var K=p.type,Q=p.stateNode;if(0===(p.flags&64)&&(\"function\"===typeof K.getDerivedStateFromError||null!==Q&&\"function\"===typeof Q.componentDidCatch&&(null===Ti||!Ti.has(Q)))){p.flags|=4096;b&=-b;p.lanes|=b;var L=Si(p,f,b);Bg(p,L);break a}}p=p.return}while(null!==p)}Zj(c)}catch(va){b=va;Y===c&&null!==c&&(Y=c=c.return);continue}break}while(1)}\nfunction Pj(){var a=oj.current;oj.current=Gh;return null===a?Gh:a}function Tj(a,b){var c=X;X|=16;var d=Pj();U===a&&W===b||Qj(a,b);do try{ak();break}catch(e){Sj(a,e)}while(1);qg();X=c;oj.current=d;if(null!==Y)throw Error(y(261));U=null;W=0;return V}function ak(){for(;null!==Y;)bk(Y)}function Rj(){for(;null!==Y&&!Qf();)bk(Y)}function bk(a){var b=ck(a.alternate,a,qj);a.memoizedProps=a.pendingProps;null===b?Zj(a):Y=b;pj.current=null}\nfunction Zj(a){var b=a;do{var c=b.alternate;a=b.return;if(0===(b.flags&2048)){c=Gi(c,b,qj);if(null!==c){Y=c;return}c=b;if(24!==c.tag&&23!==c.tag||null===c.memoizedState||0!==(qj&1073741824)||0===(c.mode&4)){for(var d=0,e=c.child;null!==e;)d|=e.lanes|e.childLanes,e=e.sibling;c.childLanes=d}null!==a&&0===(a.flags&2048)&&(null===a.firstEffect&&(a.firstEffect=b.firstEffect),null!==b.lastEffect&&(null!==a.lastEffect&&(a.lastEffect.nextEffect=b.firstEffect),a.lastEffect=b.lastEffect),1<b.flags&&(null!==\na.lastEffect?a.lastEffect.nextEffect=b:a.firstEffect=b,a.lastEffect=b))}else{c=Li(b);if(null!==c){c.flags&=2047;Y=c;return}null!==a&&(a.firstEffect=a.lastEffect=null,a.flags|=2048)}b=b.sibling;if(null!==b){Y=b;return}Y=b=a}while(null!==b);0===V&&(V=5)}function Uj(a){var b=eg();gg(99,dk.bind(null,a,b));return null}\nfunction dk(a,b){do Oj();while(null!==yj);if(0!==(X&48))throw Error(y(327));var c=a.finishedWork;if(null===c)return null;a.finishedWork=null;a.finishedLanes=0;if(c===a.current)throw Error(y(177));a.callbackNode=null;var d=c.lanes|c.childLanes,e=d,f=a.pendingLanes&~e;a.pendingLanes=e;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=e;a.mutableReadLanes&=e;a.entangledLanes&=e;e=a.entanglements;for(var g=a.eventTimes,h=a.expirationTimes;0<f;){var k=31-Vc(f),l=1<<k;e[k]=0;g[k]=-1;h[k]=-1;f&=~l}null!==\nCj&&0===(d&24)&&Cj.has(a)&&Cj.delete(a);a===U&&(Y=U=null,W=0);1<c.flags?null!==c.lastEffect?(c.lastEffect.nextEffect=c,d=c.firstEffect):d=c:d=c.firstEffect;if(null!==d){e=X;X|=32;pj.current=null;kf=fd;g=Ne();if(Oe(g)){if(\"selectionStart\"in g)h={start:g.selectionStart,end:g.selectionEnd};else a:if(h=(h=g.ownerDocument)&&h.defaultView||window,(l=h.getSelection&&h.getSelection())&&0!==l.rangeCount){h=l.anchorNode;f=l.anchorOffset;k=l.focusNode;l=l.focusOffset;try{h.nodeType,k.nodeType}catch(va){h=null;\nbreak a}var n=0,A=-1,p=-1,C=0,x=0,w=g,z=null;b:for(;;){for(var u;;){w!==h||0!==f&&3!==w.nodeType||(A=n+f);w!==k||0!==l&&3!==w.nodeType||(p=n+l);3===w.nodeType&&(n+=w.nodeValue.length);if(null===(u=w.firstChild))break;z=w;w=u}for(;;){if(w===g)break b;z===h&&++C===f&&(A=n);z===k&&++x===l&&(p=n);if(null!==(u=w.nextSibling))break;w=z;z=w.parentNode}w=u}h=-1===A||-1===p?null:{start:A,end:p}}else h=null;h=h||{start:0,end:0}}else h=null;lf={focusedElem:g,selectionRange:h};fd=!1;Ij=null;Jj=!1;Z=d;do try{ek()}catch(va){if(null===\nZ)throw Error(y(330));Wi(Z,va);Z=Z.nextEffect}while(null!==Z);Ij=null;Z=d;do try{for(g=a;null!==Z;){var t=Z.flags;t&16&&pb(Z.stateNode,\"\");if(t&128){var q=Z.alternate;if(null!==q){var v=q.ref;null!==v&&(\"function\"===typeof v?v(null):v.current=null)}}switch(t&1038){case 2:fj(Z);Z.flags&=-3;break;case 6:fj(Z);Z.flags&=-3;ij(Z.alternate,Z);break;case 1024:Z.flags&=-1025;break;case 1028:Z.flags&=-1025;ij(Z.alternate,Z);break;case 4:ij(Z.alternate,Z);break;case 8:h=Z;cj(g,h);var J=h.alternate;dj(h);null!==\nJ&&dj(J)}Z=Z.nextEffect}}catch(va){if(null===Z)throw Error(y(330));Wi(Z,va);Z=Z.nextEffect}while(null!==Z);v=lf;q=Ne();t=v.focusedElem;g=v.selectionRange;if(q!==t&&t&&t.ownerDocument&&Me(t.ownerDocument.documentElement,t)){null!==g&&Oe(t)&&(q=g.start,v=g.end,void 0===v&&(v=q),\"selectionStart\"in t?(t.selectionStart=q,t.selectionEnd=Math.min(v,t.value.length)):(v=(q=t.ownerDocument||document)&&q.defaultView||window,v.getSelection&&(v=v.getSelection(),h=t.textContent.length,J=Math.min(g.start,h),g=void 0===\ng.end?J:Math.min(g.end,h),!v.extend&&J>g&&(h=g,g=J,J=h),h=Le(t,J),f=Le(t,g),h&&f&&(1!==v.rangeCount||v.anchorNode!==h.node||v.anchorOffset!==h.offset||v.focusNode!==f.node||v.focusOffset!==f.offset)&&(q=q.createRange(),q.setStart(h.node,h.offset),v.removeAllRanges(),J>g?(v.addRange(q),v.extend(f.node,f.offset)):(q.setEnd(f.node,f.offset),v.addRange(q))))));q=[];for(v=t;v=v.parentNode;)1===v.nodeType&&q.push({element:v,left:v.scrollLeft,top:v.scrollTop});\"function\"===typeof t.focus&&t.focus();for(t=\n0;t<q.length;t++)v=q[t],v.element.scrollLeft=v.left,v.element.scrollTop=v.top}fd=!!kf;lf=kf=null;a.current=c;Z=d;do try{for(t=a;null!==Z;){var K=Z.flags;K&36&&Yi(t,Z.alternate,Z);if(K&128){q=void 0;var Q=Z.ref;if(null!==Q){var L=Z.stateNode;switch(Z.tag){case 5:q=L;break;default:q=L}\"function\"===typeof Q?Q(q):Q.current=q}}Z=Z.nextEffect}}catch(va){if(null===Z)throw Error(y(330));Wi(Z,va);Z=Z.nextEffect}while(null!==Z);Z=null;$f();X=e}else a.current=c;if(xj)xj=!1,yj=a,zj=b;else for(Z=d;null!==Z;)b=\nZ.nextEffect,Z.nextEffect=null,Z.flags&8&&(K=Z,K.sibling=null,K.stateNode=null),Z=b;d=a.pendingLanes;0===d&&(Ti=null);1===d?a===Ej?Dj++:(Dj=0,Ej=a):Dj=0;c=c.stateNode;if(Mf&&\"function\"===typeof Mf.onCommitFiberRoot)try{Mf.onCommitFiberRoot(Lf,c,void 0,64===(c.current.flags&64))}catch(va){}Mj(a,O());if(Qi)throw Qi=!1,a=Ri,Ri=null,a;if(0!==(X&8))return null;ig();return null}\nfunction ek(){for(;null!==Z;){var a=Z.alternate;Jj||null===Ij||(0!==(Z.flags&8)?dc(Z,Ij)&&(Jj=!0):13===Z.tag&&mj(a,Z)&&dc(Z,Ij)&&(Jj=!0));var b=Z.flags;0!==(b&256)&&Xi(a,Z);0===(b&512)||xj||(xj=!0,hg(97,function(){Oj();return null}));Z=Z.nextEffect}}function Oj(){if(90!==zj){var a=97<zj?97:zj;zj=90;return gg(a,fk)}return!1}function $i(a,b){Aj.push(b,a);xj||(xj=!0,hg(97,function(){Oj();return null}))}function Zi(a,b){Bj.push(b,a);xj||(xj=!0,hg(97,function(){Oj();return null}))}\nfunction fk(){if(null===yj)return!1;var a=yj;yj=null;if(0!==(X&48))throw Error(y(331));var b=X;X|=32;var c=Bj;Bj=[];for(var d=0;d<c.length;d+=2){var e=c[d],f=c[d+1],g=e.destroy;e.destroy=void 0;if(\"function\"===typeof g)try{g()}catch(k){if(null===f)throw Error(y(330));Wi(f,k)}}c=Aj;Aj=[];for(d=0;d<c.length;d+=2){e=c[d];f=c[d+1];try{var h=e.create;e.destroy=h()}catch(k){if(null===f)throw Error(y(330));Wi(f,k)}}for(h=a.current.firstEffect;null!==h;)a=h.nextEffect,h.nextEffect=null,h.flags&8&&(h.sibling=\nnull,h.stateNode=null),h=a;X=b;ig();return!0}function gk(a,b,c){b=Mi(c,b);b=Pi(a,b,1);Ag(a,b);b=Hg();a=Kj(a,1);null!==a&&($c(a,1,b),Mj(a,b))}\nfunction Wi(a,b){if(3===a.tag)gk(a,a,b);else for(var c=a.return;null!==c;){if(3===c.tag){gk(c,a,b);break}else if(1===c.tag){var d=c.stateNode;if(\"function\"===typeof c.type.getDerivedStateFromError||\"function\"===typeof d.componentDidCatch&&(null===Ti||!Ti.has(d))){a=Mi(b,a);var e=Si(c,a,1);Ag(c,e);e=Hg();c=Kj(c,1);if(null!==c)$c(c,1,e),Mj(c,e);else if(\"function\"===typeof d.componentDidCatch&&(null===Ti||!Ti.has(d)))try{d.componentDidCatch(b,a)}catch(f){}break}}c=c.return}}\nfunction Yj(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);b=Hg();a.pingedLanes|=a.suspendedLanes&c;U===a&&(W&c)===c&&(4===V||3===V&&(W&62914560)===W&&500>O()-jj?Qj(a,0):uj|=c);Mj(a,b)}function lj(a,b){var c=a.stateNode;null!==c&&c.delete(b);b=0;0===b&&(b=a.mode,0===(b&2)?b=1:0===(b&4)?b=99===eg()?1:2:(0===Gj&&(Gj=tj),b=Yc(62914560&~Gj),0===b&&(b=4194304)));c=Hg();a=Kj(a,b);null!==a&&($c(a,b,c),Mj(a,c))}var ck;\nck=function(a,b,c){var d=b.lanes;if(null!==a)if(a.memoizedProps!==b.pendingProps||N.current)ug=!0;else if(0!==(c&d))ug=0!==(a.flags&16384)?!0:!1;else{ug=!1;switch(b.tag){case 3:ri(b);sh();break;case 5:gh(b);break;case 1:Ff(b.type)&&Jf(b);break;case 4:eh(b,b.stateNode.containerInfo);break;case 10:d=b.memoizedProps.value;var e=b.type._context;I(mg,e._currentValue);e._currentValue=d;break;case 13:if(null!==b.memoizedState){if(0!==(c&b.child.childLanes))return ti(a,b,c);I(P,P.current&1);b=hi(a,b,c);return null!==\nb?b.sibling:null}I(P,P.current&1);break;case 19:d=0!==(c&b.childLanes);if(0!==(a.flags&64)){if(d)return Ai(a,b,c);b.flags|=64}e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);I(P,P.current);if(d)break;else return null;case 23:case 24:return b.lanes=0,mi(a,b,c)}return hi(a,b,c)}else ug=!1;b.lanes=0;switch(b.tag){case 2:d=b.type;null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2);a=b.pendingProps;e=Ef(b,M.current);tg(b,c);e=Ch(null,b,d,a,e,c);b.flags|=1;if(\"object\"===\ntypeof e&&null!==e&&\"function\"===typeof e.render&&void 0===e.$$typeof){b.tag=1;b.memoizedState=null;b.updateQueue=null;if(Ff(d)){var f=!0;Jf(b)}else f=!1;b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null;xg(b);var g=d.getDerivedStateFromProps;\"function\"===typeof g&&Gg(b,d,g,a);e.updater=Kg;b.stateNode=e;e._reactInternals=b;Og(b,d,a,c);b=qi(null,b,d,!0,f,c)}else b.tag=0,fi(null,b,e,c),b=b.child;return b;case 16:e=b.elementType;a:{null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2);\na=b.pendingProps;f=e._init;e=f(e._payload);b.type=e;f=b.tag=hk(e);a=lg(e,a);switch(f){case 0:b=li(null,b,e,a,c);break a;case 1:b=pi(null,b,e,a,c);break a;case 11:b=gi(null,b,e,a,c);break a;case 14:b=ii(null,b,e,lg(e.type,a),d,c);break a}throw Error(y(306,e,\"\"));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),li(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),pi(a,b,d,e,c);case 3:ri(b);d=b.updateQueue;if(null===a||null===d)throw Error(y(282));\nd=b.pendingProps;e=b.memoizedState;e=null!==e?e.element:null;yg(a,b);Cg(b,d,null,c);d=b.memoizedState.element;if(d===e)sh(),b=hi(a,b,c);else{e=b.stateNode;if(f=e.hydrate)kh=rf(b.stateNode.containerInfo.firstChild),jh=b,f=lh=!0;if(f){a=e.mutableSourceEagerHydrationData;if(null!=a)for(e=0;e<a.length;e+=2)f=a[e],f._workInProgressVersionPrimary=a[e+1],th.push(f);c=Zg(b,null,d,c);for(b.child=c;c;)c.flags=c.flags&-3|1024,c=c.sibling}else fi(a,b,d,c),sh();b=b.child}return b;case 5:return gh(b),null===a&&\nph(b),d=b.type,e=b.pendingProps,f=null!==a?a.memoizedProps:null,g=e.children,nf(d,e)?g=null:null!==f&&nf(d,f)&&(b.flags|=16),oi(a,b),fi(a,b,g,c),b.child;case 6:return null===a&&ph(b),null;case 13:return ti(a,b,c);case 4:return eh(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=Yg(b,null,d,c):fi(a,b,d,c),b.child;case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),gi(a,b,d,e,c);case 7:return fi(a,b,b.pendingProps,c),b.child;case 8:return fi(a,b,b.pendingProps.children,\nc),b.child;case 12:return fi(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;g=b.memoizedProps;f=e.value;var h=b.type._context;I(mg,h._currentValue);h._currentValue=f;if(null!==g)if(h=g.value,f=He(h,f)?0:(\"function\"===typeof d._calculateChangedBits?d._calculateChangedBits(h,f):1073741823)|0,0===f){if(g.children===e.children&&!N.current){b=hi(a,b,c);break a}}else for(h=b.child,null!==h&&(h.return=b);null!==h;){var k=h.dependencies;if(null!==k){g=h.child;for(var l=\nk.firstContext;null!==l;){if(l.context===d&&0!==(l.observedBits&f)){1===h.tag&&(l=zg(-1,c&-c),l.tag=2,Ag(h,l));h.lanes|=c;l=h.alternate;null!==l&&(l.lanes|=c);sg(h.return,c);k.lanes|=c;break}l=l.next}}else g=10===h.tag?h.type===b.type?null:h.child:h.child;if(null!==g)g.return=h;else for(g=h;null!==g;){if(g===b){g=null;break}h=g.sibling;if(null!==h){h.return=g.return;g=h;break}g=g.return}h=g}fi(a,b,e.children,c);b=b.child}return b;case 9:return e=b.type,f=b.pendingProps,d=f.children,tg(b,c),e=vg(e,\nf.unstable_observedBits),d=d(e),b.flags|=1,fi(a,b,d,c),b.child;case 14:return e=b.type,f=lg(e,b.pendingProps),f=lg(e.type,f),ii(a,b,e,f,d,c);case 15:return ki(a,b,b.type,b.pendingProps,d,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:lg(d,e),null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2),b.tag=1,Ff(d)?(a=!0,Jf(b)):a=!1,tg(b,c),Mg(b,d,e),Og(b,d,e,c),qi(null,b,d,!0,a,c);case 19:return Ai(a,b,c);case 23:return mi(a,b,c);case 24:return mi(a,b,c)}throw Error(y(156,b.tag));\n};function ik(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.flags=0;this.lastEffect=this.firstEffect=this.nextEffect=null;this.childLanes=this.lanes=0;this.alternate=null}function nh(a,b,c,d){return new ik(a,b,c,d)}function ji(a){a=a.prototype;return!(!a||!a.isReactComponent)}\nfunction hk(a){if(\"function\"===typeof a)return ji(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===Aa)return 11;if(a===Da)return 14}return 2}\nfunction Tg(a,b){var c=a.alternate;null===c?(c=nh(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a.stateNode,c.alternate=a,a.alternate=c):(c.pendingProps=b,c.type=a.type,c.flags=0,c.nextEffect=null,c.firstEffect=null,c.lastEffect=null);c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoizedProps=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b=a.dependencies;c.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext};\nc.sibling=a.sibling;c.index=a.index;c.ref=a.ref;return c}\nfunction Vg(a,b,c,d,e,f){var g=2;d=a;if(\"function\"===typeof a)ji(a)&&(g=1);else if(\"string\"===typeof a)g=5;else a:switch(a){case ua:return Xg(c.children,e,f,b);case Ha:g=8;e|=16;break;case wa:g=8;e|=1;break;case xa:return a=nh(12,c,b,e|8),a.elementType=xa,a.type=xa,a.lanes=f,a;case Ba:return a=nh(13,c,b,e),a.type=Ba,a.elementType=Ba,a.lanes=f,a;case Ca:return a=nh(19,c,b,e),a.elementType=Ca,a.lanes=f,a;case Ia:return vi(c,e,f,b);case Ja:return a=nh(24,c,b,e),a.elementType=Ja,a.lanes=f,a;default:if(\"object\"===\ntypeof a&&null!==a)switch(a.$$typeof){case ya:g=10;break a;case za:g=9;break a;case Aa:g=11;break a;case Da:g=14;break a;case Ea:g=16;d=null;break a;case Fa:g=22;break a}throw Error(y(130,null==a?a:typeof a,\"\"));}b=nh(g,c,b,e);b.elementType=a;b.type=d;b.lanes=f;return b}function Xg(a,b,c,d){a=nh(7,a,d,b);a.lanes=c;return a}function vi(a,b,c,d){a=nh(23,a,d,b);a.elementType=Ia;a.lanes=c;return a}function Ug(a,b,c){a=nh(6,a,null,b);a.lanes=c;return a}\nfunction Wg(a,b,c){b=nh(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}\nfunction jk(a,b,c){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.pendingContext=this.context=null;this.hydrate=c;this.callbackNode=null;this.callbackPriority=0;this.eventTimes=Zc(0);this.expirationTimes=Zc(-1);this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=Zc(0);this.mutableSourceEagerHydrationData=null}\nfunction kk(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:ta,key:null==d?null:\"\"+d,children:a,containerInfo:b,implementation:c}}\nfunction lk(a,b,c,d){var e=b.current,f=Hg(),g=Ig(e);a:if(c){c=c._reactInternals;b:{if(Zb(c)!==c||1!==c.tag)throw Error(y(170));var h=c;do{switch(h.tag){case 3:h=h.stateNode.context;break b;case 1:if(Ff(h.type)){h=h.stateNode.__reactInternalMemoizedMergedChildContext;break b}}h=h.return}while(null!==h);throw Error(y(171));}if(1===c.tag){var k=c.type;if(Ff(k)){c=If(c,k,h);break a}}c=h}else c=Cf;null===b.context?b.context=c:b.pendingContext=c;b=zg(f,g);b.payload={element:a};d=void 0===d?null:d;null!==\nd&&(b.callback=d);Ag(e,b);Jg(e,g,f);return g}function mk(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 5:return a.child.stateNode;default:return a.child.stateNode}}function nk(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b}}function ok(a,b){nk(a,b);(a=a.alternate)&&nk(a,b)}function pk(){return null}\nfunction qk(a,b,c){var d=null!=c&&null!=c.hydrationOptions&&c.hydrationOptions.mutableSources||null;c=new jk(a,b,null!=c&&!0===c.hydrate);b=nh(3,null,null,2===b?7:1===b?3:0);c.current=b;b.stateNode=c;xg(b);a[ff]=c.current;cf(8===a.nodeType?a.parentNode:a);if(d)for(a=0;a<d.length;a++){b=d[a];var e=b._getVersion;e=e(b._source);null==c.mutableSourceEagerHydrationData?c.mutableSourceEagerHydrationData=[b,e]:c.mutableSourceEagerHydrationData.push(b,e)}this._internalRoot=c}\nqk.prototype.render=function(a){lk(a,this._internalRoot,null,null)};qk.prototype.unmount=function(){var a=this._internalRoot,b=a.containerInfo;lk(null,a,null,function(){b[ff]=null})};function rk(a){return!(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||\" react-mount-point-unstable \"!==a.nodeValue))}\nfunction sk(a,b){b||(b=a?9===a.nodeType?a.documentElement:a.firstChild:null,b=!(!b||1!==b.nodeType||!b.hasAttribute(\"data-reactroot\")));if(!b)for(var c;c=a.lastChild;)a.removeChild(c);return new qk(a,0,b?{hydrate:!0}:void 0)}\nfunction tk(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f._internalRoot;if(\"function\"===typeof e){var h=e;e=function(){var a=mk(g);h.call(a)}}lk(b,g,a,e)}else{f=c._reactRootContainer=sk(c,d);g=f._internalRoot;if(\"function\"===typeof e){var k=e;e=function(){var a=mk(g);k.call(a)}}Xj(function(){lk(b,g,a,e)})}return mk(g)}ec=function(a){if(13===a.tag){var b=Hg();Jg(a,4,b);ok(a,4)}};fc=function(a){if(13===a.tag){var b=Hg();Jg(a,67108864,b);ok(a,67108864)}};\ngc=function(a){if(13===a.tag){var b=Hg(),c=Ig(a);Jg(a,c,b);ok(a,c)}};hc=function(a,b){return b()};\nyb=function(a,b,c){switch(b){case \"input\":ab(a,c);b=c.name;if(\"radio\"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll(\"input[name=\"+JSON.stringify(\"\"+b)+'][type=\"radio\"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Db(d);if(!e)throw Error(y(90));Wa(d);ab(d,e)}}}break;case \"textarea\":ib(a,c);break;case \"select\":b=c.value,null!=b&&fb(a,!!c.multiple,b,!1)}};Gb=Wj;\nHb=function(a,b,c,d,e){var f=X;X|=4;try{return gg(98,a.bind(null,b,c,d,e))}finally{X=f,0===X&&(wj(),ig())}};Ib=function(){0===(X&49)&&(Vj(),Oj())};Jb=function(a,b){var c=X;X|=2;try{return a(b)}finally{X=c,0===X&&(wj(),ig())}};function uk(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!rk(b))throw Error(y(200));return kk(a,b,null,c)}var vk={Events:[Cb,ue,Db,Eb,Fb,Oj,{current:!1}]},wk={findFiberByHostInstance:wc,bundleType:0,version:\"17.0.1\",rendererPackageName:\"react-dom\"};\nvar xk={bundleType:wk.bundleType,version:wk.version,rendererPackageName:wk.rendererPackageName,rendererConfig:wk.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:ra.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=cc(a);return null===a?null:a.stateNode},findFiberByHostInstance:wk.findFiberByHostInstance||\npk,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null};if(\"undefined\"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var yk=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!yk.isDisabled&&yk.supportsFiber)try{Lf=yk.inject(xk),Mf=yk}catch(a){}}exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=vk;exports.createPortal=uk;\nexports.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if(\"function\"===typeof a.render)throw Error(y(188));throw Error(y(268,Object.keys(a)));}a=cc(b);a=null===a?null:a.stateNode;return a};exports.flushSync=function(a,b){var c=X;if(0!==(c&48))return a(b);X|=1;try{if(a)return gg(99,a.bind(null,b))}finally{X=c,ig()}};exports.hydrate=function(a,b,c){if(!rk(b))throw Error(y(200));return tk(null,a,b,!0,c)};\nexports.render=function(a,b,c){if(!rk(b))throw Error(y(200));return tk(null,a,b,!1,c)};exports.unmountComponentAtNode=function(a){if(!rk(a))throw Error(y(40));return a._reactRootContainer?(Xj(function(){tk(null,null,a,!1,function(){a._reactRootContainer=null;a[ff]=null})}),!0):!1};exports.unstable_batchedUpdates=Wj;exports.unstable_createPortal=function(a,b){return uk(a,b,2<arguments.length&&void 0!==arguments[2]?arguments[2]:null)};\nexports.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!rk(c))throw Error(y(200));if(null==a||void 0===a._reactInternals)throw Error(y(38));return tk(a,b,c,!1,d)};exports.version=\"17.0.1\";\n"],"sourceRoot":""}
//# sourceURL=webpack-internal:///4448

/** @license React v0.20.1
 * scheduler.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
var f, g, h, k;
if ("object" === typeof performance && "function" === typeof performance.now) {
    var l = performance;
    exports.unstable_now = function() {
        return l.now()
    }
} else {
    var p = Date,
        q = p.now();
    exports.unstable_now = function() {
        return p.now() - q
    }
}
if ("undefined" === typeof window || "function" !== typeof MessageChannel) {
    var t = null,
        u = null,
        w = function() {
            if (null !== t) try {
                var a = exports.unstable_now();
                t(!0, a);
                t = null
            } catch (b) {
                throw setTimeout(w, 0), b;
            }
        };
    f = function(a) {
        null !== t ? setTimeout(f, 0, a) : (t = a, setTimeout(w, 0))
    };
    g = function(a, b) {
        u = setTimeout(a, b)
    };
    h = function() {
        clearTimeout(u)
    };
    exports.unstable_shouldYield = function() {
        return !1
    };
    k = exports.unstable_forceFrameRate = function() {}
} else {
    var x = window.setTimeout,
        y = window.clearTimeout;
    if ("undefined" !== typeof console) {
        var z =
            window.cancelAnimationFrame;
        "function" !== typeof window.requestAnimationFrame && console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");
        "function" !== typeof z && console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills")
    }
    var A = !1,
        B = null,
        C = -1,
        D = 5,
        E = 0;
    exports.unstable_shouldYield = function() {
        return exports.unstable_now() >=
            E
    };
    k = function() {};
    exports.unstable_forceFrameRate = function(a) {
        0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : D = 0 < a ? Math.floor(1E3 / a) : 5
    };
    var F = new MessageChannel,
        G = F.port2;
    F.port1.onmessage = function() {
        if (null !== B) {
            var a = exports.unstable_now();
            E = a + D;
            try {
                B(!0, a) ? G.postMessage(null) : (A = !1, B = null)
            } catch (b) {
                throw G.postMessage(null), b;
            }
        } else A = !1
    };
    f = function(a) {
        B = a;
        A || (A = !0, G.postMessage(null))
    };
    g = function(a, b) {
        C =
            x(function() {
                a(exports.unstable_now())
            }, b)
    };
    h = function() {
        y(C);
        C = -1
    }
}

function H(a, b) {
    var c = a.length;
    a.push(b);
    a: for (;;) {
        var d = c - 1 >>> 1,
            e = a[d];
        if (void 0 !== e && 0 < I(e, b)) a[d] = b, a[c] = e, c = d;
        else break a
    }
}

function J(a) {
    a = a[0];
    return void 0 === a ? null : a
}

function K(a) {
    var b = a[0];
    if (void 0 !== b) {
        var c = a.pop();
        if (c !== b) {
            a[0] = c;
            a: for (var d = 0, e = a.length; d < e;) {
                var m = 2 * (d + 1) - 1,
                    n = a[m],
                    v = m + 1,
                    r = a[v];
                if (void 0 !== n && 0 > I(n, c)) void 0 !== r && 0 > I(r, n) ? (a[d] = r, a[v] = c, d = v) : (a[d] = n, a[m] = c, d = m);
                else if (void 0 !== r && 0 > I(r, c)) a[d] = r, a[v] = c, d = v;
                else break a
            }
        }
        return b
    }
    return null
}

function I(a, b) {
    var c = a.sortIndex - b.sortIndex;
    return 0 !== c ? c : a.id - b.id
}
var L = [],
    M = [],
    N = 1,
    O = null,
    P = 3,
    Q = !1,
    R = !1,
    S = !1;

function T(a) {
    for (var b = J(M); null !== b;) {
        if (null === b.callback) K(M);
        else if (b.startTime <= a) K(M), b.sortIndex = b.expirationTime, H(L, b);
        else break;
        b = J(M)
    }
}

function U(a) {
    S = !1;
    T(a);
    if (!R)
        if (null !== J(L)) R = !0, f(V);
        else {
            var b = J(M);
            null !== b && g(U, b.startTime - a)
        }
}

function V(a, b) {
    R = !1;
    S && (S = !1, h());
    Q = !0;
    var c = P;
    try {
        T(b);
        for (O = J(L); null !== O && (!(O.expirationTime > b) || a && !exports.unstable_shouldYield());) {
            var d = O.callback;
            if ("function" === typeof d) {
                O.callback = null;
                P = O.priorityLevel;
                var e = d(O.expirationTime <= b);
                b = exports.unstable_now();
                "function" === typeof e ? O.callback = e : O === J(L) && K(L);
                T(b)
            } else K(L);
            O = J(L)
        }
        if (null !== O) var m = !0;
        else {
            var n = J(M);
            null !== n && g(U, n.startTime - b);
            m = !1
        }
        return m
    } finally {
        O = null, P = c, Q = !1
    }
}
var W = k;
exports.unstable_IdlePriority = 5;
exports.unstable_ImmediatePriority = 1;
exports.unstable_LowPriority = 4;
exports.unstable_NormalPriority = 3;
exports.unstable_Profiling = null;
exports.unstable_UserBlockingPriority = 2;
exports.unstable_cancelCallback = function(a) {
    a.callback = null
};
exports.unstable_continueExecution = function() {
    R || Q || (R = !0, f(V))
};
exports.unstable_getCurrentPriorityLevel = function() {
    return P
};
exports.unstable_getFirstCallbackNode = function() {
    return J(L)
};
exports.unstable_next = function(a) {
    switch (P) {
        case 1:
        case 2:
        case 3:
            var b = 3;
            break;
        default:
            b = P
    }
    var c = P;
    P = b;
    try {
        return a()
    } finally {
        P = c
    }
};
exports.unstable_pauseExecution = function() {};
exports.unstable_requestPaint = W;
exports.unstable_runWithPriority = function(a, b) {
    switch (a) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
            break;
        default:
            a = 3
    }
    var c = P;
    P = a;
    try {
        return b()
    } finally {
        P = c
    }
};
exports.unstable_scheduleCallback = function(a, b, c) {
    var d = exports.unstable_now();
    "object" === typeof c && null !== c ? (c = c.delay, c = "number" === typeof c && 0 < c ? d + c : d) : c = d;
    switch (a) {
        case 1:
            var e = -1;
            break;
        case 2:
            e = 250;
            break;
        case 5:
            e = 1073741823;
            break;
        case 4:
            e = 1E4;
            break;
        default:
            e = 5E3
    }
    e = c + e;
    a = {
        id: N++,
        callback: b,
        priorityLevel: a,
        startTime: c,
        expirationTime: e,
        sortIndex: -1
    };
    c > d ? (a.sortIndex = c, H(M, a), null === J(L) && a === J(M) && (S ? h() : S = !0, g(U, c - d))) : (a.sortIndex = e, H(L, a), R || Q || (R = !0, f(V)));
    return a
};
exports.unstable_wrapCallback = function(a) {
    var b = P;
    return function() {
        var c = P;
        P = b;
        try {
            return a.apply(this, arguments)
        } finally {
            P = c
        }
    }
};
//# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://aem-cms-code/./node_modules/scheduler/cjs/scheduler.production.min.js?fb07"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACa,YAAY,uEAAuE,kBAAkB,oBAAoB,YAAY,gBAAgB,KAAK,qBAAqB,oBAAoB,YAAY;AAC5N,oEAAoE,+BAA+B,gBAAgB,6BAA6B,QAAQ,OAAO,SAAS,2BAA2B,cAAc,kDAAkD,gBAAgB,mBAAmB,aAAa,iBAAiB,4BAA4B,YAAY,UAAU,EAAE,+BAA+B,cAAc,KAAK,8CAA8C,iCAAiC;AACzf,4BAA4B,sNAAsN,0LAA0L,6BAA6B,4BAA4B,YAAY;AACjf,GAAG,eAAe,+BAA+B,aAAa,uKAAuK,mCAAmC,6BAA6B,aAAa,6BAA6B,MAAM,IAAI,0CAA0C,SAAS,8BAA8B,WAAW,cAAc,IAAI,+BAA+B,gBAAgB;AACtf,aAAa,0BAA0B,KAAK,aAAa,KAAK,MAAM,gBAAgB,eAAe,UAAU,QAAQ,EAAE,qBAAqB,0CAA0C,cAAc,cAAc,OAAO;AACzN,cAAc,WAAW,eAAe,cAAc,UAAU,OAAO,yBAAyB,IAAI,EAAE,oCAAoC,qFAAqF,+CAA+C,cAAc,SAAS,YAAY,gBAAgB,8BAA8B,yBAAyB;AACxX,cAAc,eAAe,SAAS,EAAE,0BAA0B,gEAAgE,WAAW,QAAQ,cAAc,KAAK,KAAK,+BAA+B,KAAK,WAAW;AAC5N,gBAAgB,KAAK,cAAc,KAAK,QAAQ,IAAI,KAAK,WAAW,sEAAsE,EAAE,iBAAiB,0BAA0B,gBAAgB,kBAAkB,6BAA6B,yBAAyB,kDAAkD,KAAK,UAAU,OAAO,qBAAqB,KAAK,WAAW,6BAA6B,KAAK,SAAS,QAAQ,iBAAiB,QAAQ,6BAA6B;AACre,kCAAkC,GAAG,4BAA4B,GAAG,+BAA+B,GAAG,0BAA0B,MAAM,qCAAqC,GAAG,+BAA+B,aAAa,iBAAiB,kCAAkC,YAAY,mBAAmB,wCAAwC,YAAY,UAAU,qCAAqC,YAAY;AAC3Z,qBAAqB,aAAa,UAAU,6BAA6B,MAAM,YAAY,QAAQ,IAAI,IAAI,WAAW,QAAQ,MAAM,+BAA+B,cAAc,6BAA6B,GAAG,gCAAgC,eAAe,UAAU,yCAAyC,YAAY,QAAQ,IAAI,IAAI,WAAW,QAAQ;AAClW,iCAAiC,iBAAiB,6BAA6B,+EAA+E,UAAU,gBAAgB,MAAM,aAAa,MAAM,oBAAoB,MAAM,aAAa,MAAM,cAAc,MAAM,GAAG,6EAA6E,iHAAiH;AACnd,6BAA6B,aAAa,QAAQ,kBAAkB,QAAQ,IAAI,IAAI,+BAA+B,QAAQ","file":"53.js","sourcesContent":["/** @license React v0.20.1\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f,g,h,k;if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}\nif(\"undefined\"===typeof window||\"function\"!==typeof MessageChannel){var t=null,u=null,w=function(){if(null!==t)try{var a=exports.unstable_now();t(!0,a);t=null}catch(b){throw setTimeout(w,0),b;}};f=function(a){null!==t?setTimeout(f,0,a):(t=a,setTimeout(w,0))};g=function(a,b){u=setTimeout(a,b)};h=function(){clearTimeout(u)};exports.unstable_shouldYield=function(){return!1};k=exports.unstable_forceFrameRate=function(){}}else{var x=window.setTimeout,y=window.clearTimeout;if(\"undefined\"!==typeof console){var z=\nwindow.cancelAnimationFrame;\"function\"!==typeof window.requestAnimationFrame&&console.error(\"This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills\");\"function\"!==typeof z&&console.error(\"This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills\")}var A=!1,B=null,C=-1,D=5,E=0;exports.unstable_shouldYield=function(){return exports.unstable_now()>=\nE};k=function(){};exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):D=0<a?Math.floor(1E3/a):5};var F=new MessageChannel,G=F.port2;F.port1.onmessage=function(){if(null!==B){var a=exports.unstable_now();E=a+D;try{B(!0,a)?G.postMessage(null):(A=!1,B=null)}catch(b){throw G.postMessage(null),b;}}else A=!1};f=function(a){B=a;A||(A=!0,G.postMessage(null))};g=function(a,b){C=\nx(function(){a(exports.unstable_now())},b)};h=function(){y(C);C=-1}}function H(a,b){var c=a.length;a.push(b);a:for(;;){var d=c-1>>>1,e=a[d];if(void 0!==e&&0<I(e,b))a[d]=b,a[c]=e,c=d;else break a}}function J(a){a=a[0];return void 0===a?null:a}\nfunction K(a){var b=a[0];if(void 0!==b){var c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length;d<e;){var m=2*(d+1)-1,n=a[m],v=m+1,r=a[v];if(void 0!==n&&0>I(n,c))void 0!==r&&0>I(r,n)?(a[d]=r,a[v]=c,d=v):(a[d]=n,a[m]=c,d=m);else if(void 0!==r&&0>I(r,c))a[d]=r,a[v]=c,d=v;else break a}}return b}return null}function I(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var L=[],M=[],N=1,O=null,P=3,Q=!1,R=!1,S=!1;\nfunction T(a){for(var b=J(M);null!==b;){if(null===b.callback)K(M);else if(b.startTime<=a)K(M),b.sortIndex=b.expirationTime,H(L,b);else break;b=J(M)}}function U(a){S=!1;T(a);if(!R)if(null!==J(L))R=!0,f(V);else{var b=J(M);null!==b&&g(U,b.startTime-a)}}\nfunction V(a,b){R=!1;S&&(S=!1,h());Q=!0;var c=P;try{T(b);for(O=J(L);null!==O&&(!(O.expirationTime>b)||a&&!exports.unstable_shouldYield());){var d=O.callback;if(\"function\"===typeof d){O.callback=null;P=O.priorityLevel;var e=d(O.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?O.callback=e:O===J(L)&&K(L);T(b)}else K(L);O=J(L)}if(null!==O)var m=!0;else{var n=J(M);null!==n&&g(U,n.startTime-b);m=!1}return m}finally{O=null,P=c,Q=!1}}var W=k;exports.unstable_IdlePriority=5;\nexports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){R||Q||(R=!0,f(V))};exports.unstable_getCurrentPriorityLevel=function(){return P};exports.unstable_getFirstCallbackNode=function(){return J(L)};\nexports.unstable_next=function(a){switch(P){case 1:case 2:case 3:var b=3;break;default:b=P}var c=P;P=b;try{return a()}finally{P=c}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=W;exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=P;P=a;try{return b()}finally{P=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:N++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,H(M,a),null===J(L)&&a===J(M)&&(S?h():S=!0,g(U,c-d))):(a.sortIndex=e,H(L,a),R||Q||(R=!0,f(V)));return a};\nexports.unstable_wrapCallback=function(a){var b=P;return function(){var c=P;P=b;try{return a.apply(this,arguments)}finally{P=c}}};\n"],"sourceRoot":""}
//# sourceURL=webpack-internal:///53

; // CONCATENATED MODULE: ./ui.frontend/src/main/global/js/variables/constants.js
var CONSTANTS = {
    HASH_CHAR_LIMIT: 50,
    CLASSES: {
        HIDDEN: 'is-hidden',
        ACTIVE: 'is-active',
        CURRENT: 'is-current',
        FOCUSED: 'is-focused',
        ERROR: 'is-error',
        OPEN: 'is-open',
        DISABLED: 'is-disabled',
        HAS_ERROR: 'has-error'
    },
    KEYBOARD: {
        BACKSPACE: 8,
        TAB: 9,
        ENTER: 13,
        ESCAPE: 27,
        LEFT: 37,
        UP: 38,
        RIGHT: 39,
        DOWN: 40,
        DELETE: 46,
        FORWARD_SLASH: 191
    },
    ATTRIBUTES: {
        DISABLED: 'disabled',
        READONLY: 'readonly',
        REQUIRED: 'required',
        MAX: 'max',
        MIN: 'min'
    },
    BREAKPOINTS: {
        XSM: 0,
        SM: 480,
        MD: 680,
        LG: 970,
        XL: 1170,
        XXL: 1600
    }
};; // CONCATENATED MODULE: ./ui.frontend/src/main/global/js/helpers/debounce.js
/**
 * debounce - Debounce helper method
 * Based on https://github.com/rhysbrettbowen/debounce/blob/master/debounce.js
 *
 * @param  {Function} func  target function to be called
 * @param  {string} wait    wait time after the last call of target function before it is called
 * @return {Function}
 */
function debounce(func, wait) {
    // we need to save these in the closure
    var timeout, args, context, timestamp;
    return function() {
        var _debouncedFunc, last; // save details of latest call


        context = this;
        args = [].slice.call(arguments, 0);
        timestamp = new Date(); // this is where the magic happens

        _debouncedFunc = function debouncedFunc() {
            // how long ago was the last call
            last = new Date() - timestamp; // if the latest call was less that the wait period ago
            // then we reset the timeout to wait for the difference

            if (last < wait) {
                timeout = setTimeout(_debouncedFunc, wait - last);
            } else {
                // or if not we can null out the timer and run the latest
                timeout = null;
                func.apply(context, args);
            }
        }; // we only need to set the timer now if one isn't already running


        if (!timeout) {
            timeout = setTimeout(_debouncedFunc, wait);
        }
    };
}; // CONCATENATED MODULE: ./ui.frontend/src/main/global/js/helpers/restrictFocus.js
function set(namespace, $container) {
    var eventType = 'focusin.' + namespace;
    $container.attr('tabindex', '0');
    $(document).on(eventType, function(event) {
        if (!$container[0].contains(event.target)) {
            event.stopPropagation();
            $container.focus();
        }
    });
}

function unset(namespace, $container) {
    var eventType = 'focusin.' + namespace;
    $container.attr('tabindex', '-1');
    $(document).off(eventType);
}; // CONCATENATED MODULE: ./ui.apps/src/main/content/jcr_root/apps/global/components/corp-site/search/search-form-component/clientlib/src/js/search-form-component.js


// type ahead keys

var KEYCODE_TAB = CONSTANTS.KEYBOARD.TAB;
var KEYCODE_ENTER = CONSTANTS.KEYBOARD.ENTER;
var KEYCODE_ESCAPE = CONSTANTS.KEYBOARD.ESCAPE;
var KEYCODE_UP = CONSTANTS.KEYBOARD.UP;
var KEYCODE_DOWN = CONSTANTS.KEYBOARD.DOWN; // type ahead classes and states

var CLASS_WRAPPER = '.js-search-form-input-wrap';
var CLASS_INPUT = '.js-search-form-input';
var CLASS_TYPEAHEAD = '.search-typeahead';
var IS_RESULTS_PAGE = $('.wrapper-body').hasClass('has-search-results');
var CHAR_THRESHOLD = 3;
var AUTO_SUGGEST_DEBOUNCE_WAIT = 200; // search drawer classes

var CLASS_DRAWER_OPEN = 'is-open';
var CLASS_NO_SCROLL = 'no-scroll'; // search drawer view elements

var CLASS_CTA_SEARCH_OPEN = 'cta-search-form-open';
var CLASS_CTA_SEARCH_CLOSE = 'cta-search-form-close';
var CLASS_CTA_SEARCH_OVERLAYS = 'search-overlay';
var $body = $('body'); // List holding instance level global data for all instances

var _instancesData = [];
/**
 * _updateTypeahead - takes data from the suggestions api and updates the dom with results as
 *                    well as making the typeahead visible.
 *
 * @param  {object} data   object containing raw results from the api
 * @param  {object} $input jQuery object representing the current input in use.
 */

function _updateTypeahead(data, $input) {
        if (data && data.results && data.results.length) {
            var resultsList = data.results;
            var $typeahead = $input.siblings(CLASS_TYPEAHEAD);
            var formAction = $input.parents('form').attr('action');
            var listHtml = '';

            for (var i = 0; i < resultsList.length; i++) {
                // build the html to add to the dom.
                var suggestion = resultsList[i];
                var encodedSuggestion = encodeURI(suggestion);
                var link = "".concat(formAction, "?q=").concat(encodedSuggestion, "&ref=auto");
                listHtml += "<li role=\"option\" aria-selected=\"false\"><a href=\"".concat(link, "\" data-query=\"").concat(suggestion, "\" title=\"Search for ").concat(suggestion, "\">").concat(suggestion, "</a></li>\n");
            }

            $typeahead.removeClass('is-hidden').attr('aria-expanded', true).find('ul').html(listHtml);
        } else {
            // if there are no suggestions clear the typeahead ui.
            _clearTypeahead($input);
        }
    }
    /**
     * _clearTypeahead - clears the typeahead results and hides it.
     *
     * @param  {object} $input jQuery object representing the current input in use.
     * @return {Boolean}       allow event to propagate.
     */


function _clearTypeahead($input) {
        var $typeahead = $input.siblings(CLASS_TYPEAHEAD);
        $typeahead.addClass('is-hidden').attr('aria-expanded', false).find('ul').empty();
        return true;
    }
    /**
     * _getMatchingSuggestionsList - creates a list of matching suggestions from the data pool
     *
     * @param {String} inputValue  the value of the input as a trimmed string
     * @param {Object} $input  the $input element jQuery object
     * @returns {Array}  list of matching suggestions from input query against auto suggest result data pool
     */


function _getMatchingSuggestionsList(inputValue, $input) {
        var maxSuggestCount = $input.attr('data-max-suggestions');
        var instanceId = parseInt($input.attr('data-instance-id'), 10);
        var instanceData = _instancesData[instanceId - 1] || {};
        var autoSuggestPoolData = instanceData.autoSuggestData || [];
        var matchingSuggestions = [];

        for (var i = 0; i < autoSuggestPoolData.length; i++) {
            var suggestion = autoSuggestPoolData[i];

            if (suggestion.toLowerCase().indexOf(inputValue.trim().toLowerCase()) === 0) {
                matchingSuggestions.push(suggestion);

                if (matchingSuggestions.length >= maxSuggestCount) {
                    break;
                }
            }
        }

        return matchingSuggestions;
    }
    /**
     * _findSuggestions - makes the request to the suggestions api and acts accordingly through
     *                    callback functions.
     *
     * @param  {String} inputValue the value of the input as a trimmed string.
     * @param  {object} $input jQuery object representing the current input in use.
     */


function _findSuggestions(inputValue, $input) {
        // TODO: update to get suggestion results list from S&P endpoint once the JSON feed is ready
        // prep suggestion data for view updates
        var suggestionsData = {
            results: _getMatchingSuggestionsList(inputValue, $input)
        }; // this function cleans up the typeahead if no results are returned or if an error has
        // occurred, so no error callback is required.

        _updateTypeahead(suggestionsData, $input);
    }
    /**
     * _keyboardNavigation - allows keyboard navigation through and out of the typeahead. this is
     *                       used by functions bound to both the input and the typeahead.
     *
     * @param  {object} $input     jQuery object representing the current input in use.
     * @param  {object} $typeahead jQuery object representing the current typeahead displayed.
     * @param  {object} event      the keydown event
     * @return {boolean}           prevent default event behaviour
     */


function _keyboardNavigation($input, $typeahead, event) {
        var inputIsFocussed = $input.is(':focus');
        var $suggestions = $typeahead.find('a');
        var numSuggestions = $suggestions.length; // if the input focussed jump to either end of the typeahead suggestions.

        if (inputIsFocussed && $.inArray(event.keyCode, [KEYCODE_UP, KEYCODE_DOWN]) > -1) {
            var selectIndex = event.keyCode === KEYCODE_DOWN ? 0 : numSuggestions - 1;

            _updateSelectedSuggestion($suggestions, selectIndex);

            return false; // if the user hits enter on a typeahead suggestion, redirect them to the search results, as
            // long as they aren't currently on the results page.
        }

        if (event.keyCode === KEYCODE_ENTER && !IS_RESULTS_PAGE && !inputIsFocussed) {
            window.location = event.currentTarget.href;
            return false; // if they are using arrow or tab navigation move them to the next appropriate result.
        }

        if ($.inArray(event.keyCode, [KEYCODE_TAB, KEYCODE_UP, KEYCODE_DOWN]) > -1) {
            var currentIndex = $suggestions.index(event.currentTarget); // go down an index for up arrow or shift-tab, otherwise up.

            var indexOffset = event.keyCode === KEYCODE_UP || event.shiftKey && event.keyCode === KEYCODE_TAB ? -1 : 1;

            var _selectIndex = currentIndex + indexOffset;

            if (_selectIndex === -1 || _selectIndex === numSuggestions) {
                // if not an index within the range focus the input
                $input.focus();

                _updateSelectedSuggestion($suggestions);
            } else {
                // otherwise navigate the typeahead.
                _updateSelectedSuggestion($suggestions, _selectIndex);
            }

            return false;
        }

        if (!inputIsFocussed && event.keyCode === KEYCODE_ESCAPE) {
            $input.focus();
            return _clearTypeahead($input);
        }
    }
    /**
     * _updateSelectedSuggestion - update auto suggestion item selected states on view
     *
     * @param  {object} $suggestions  jquery collection of all suggestion anchor items
     * @param  {object} selectIndex  current selected item index
     * @return {void}
     */


function _updateSelectedSuggestion($suggestions) {
        var selectIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
        $suggestions.each(function(idx, ele) {
            var $suggestion = $(ele);
            var $suggestionWrapper = $suggestion.parent('li');

            if (idx === selectIndex) {
                $suggestion.focus();
                $suggestionWrapper.attr('aria-selected', 'true');
            } else {
                $suggestionWrapper.attr('aria-selected', 'false');
            }
        });
    }
    /**
     * _inputKeyBindings - monitor keyboard events on the search input and trigger appropriate behaviour.
     *
     * @param  {object} event   the keyup event.
     */


function _inputKeyBindings(event) {
        var $input = $(event.currentTarget);
        var inputValue = event.currentTarget.value.trim(); // prevent arrow keys from keyboard nav from re-rendering the suggestions.

        if ($.inArray(event.keyCode, [KEYCODE_ENTER, KEYCODE_TAB, KEYCODE_UP, KEYCODE_DOWN]) > -1) {
            return;
        }

        if (inputValue.length >= CHAR_THRESHOLD) {
            // try to provide suggestions in the typeahead dropdown
            _findSuggestions(inputValue, $input);
        } else {
            // clean up and close the typeahead.
            return _clearTypeahead($input);
        }
    }
    /**
     * _inputNavBindings - allow the user to enter the typeahead using arrow keys.
     *
     * @param  {object} event   the keydown event.
     * @return {boolean}        prevent default behaviour.
     */


function _inputNavBindings(event) {
        var $input = $(event.currentTarget);
        var $typeahead = $input.siblings(CLASS_TYPEAHEAD); // up and down arrows will enter the typeahead.

        if ($.inArray(event.keyCode, [KEYCODE_ESCAPE, KEYCODE_ENTER, KEYCODE_UP, KEYCODE_DOWN]) > -1) {
            // if the typeahead isn't visible, don't hijack the keyboard.
            if (!$typeahead.is(':visible')) {
                return;
            } // keyboard navigation into and out of typeahead from input.


            return _keyboardNavigation($input, $typeahead, event);
        }
    }
    /**
     * _typeaheadKeyBindings - setting up handling of keyboard navigation within the typeahead.
     *
     * @param  {object} event   the keydown event.
     */


function _typeaheadKeyBindings(event) {
        var $typeahead = $(event.currentTarget).closest(CLASS_TYPEAHEAD);
        var $input = $typeahead.siblings(CLASS_INPUT);
        return _keyboardNavigation($input, $typeahead, event);
    }
    /**
     * _handleFormSubmission - hijacks the form submission so the query string can be uri encoded
     *                         before being manually redirected to the results page.
     *
     * @param  {object} event  the submit event
     * @return {boolean}  prevent default form submission.
     */


function _handleFormSubmission(event) {
        var $form = $(event.target);
        var $input = $form.find(CLASS_INPUT);
        var query = $input.val().trim();
        window.location = "".concat($form.attr('action'), "?q=").concat(encodeURIComponent(query));
        return false;
    }
    /**
     * _handleSearchFieldFocusChange - update presentational focus state when search field focus state changes
     *
     * @param  {object} event  the focus change events
     * @return {void}
     */


function _handleSearchFieldFocusChange(event) {
        var $inputWrapper = $(event.target).closest(CLASS_WRAPPER);

        if (event.type === 'focus') {
            $inputWrapper.addClass(CONSTANTS.CLASSES.FOCUSED);
        } else if (event.type === 'blur') {
            $inputWrapper.removeClass(CONSTANTS.CLASSES.FOCUSED);
        }
    }
    /**
     * _closeTypeaheadOnBlur - dismiss all typeaheads when click out of the search input
     *
     * @return {boolean}  do not prevent propagation.
     */


function _closeTypeaheadOnBlur(event) {
        var clickedOutsideSearchForm = !$(event.target).closest(CLASS_WRAPPER).length;

        if (clickedOutsideSearchForm) {
            $("".concat(CLASS_INPUT, "[data-typeahead=true]")).each(function($element) {
                _clearTypeahead($($element));
            });
        }

        return true;
    }
    /**
     * _initTypeahead - set up various event bindings to control the typeahead.
     */


function _initTypeahead() {
        $(document) // bind to key events on the inputs.
            .on('input', "".concat(CLASS_INPUT, "[data-typeahead=true]"), debounce(_inputKeyBindings, AUTO_SUGGEST_DEBOUNCE_WAIT)).on('keydown', "".concat(CLASS_INPUT, "[data-typeahead=true]"), _inputNavBindings).on('internal-search', "".concat(CLASS_INPUT, "[data-typeahead=true]"), function(e) {
                _clearTypeahead($(e.target));
            }) // bind key events to the typeahead anchors.
            .on('keydown', "".concat(CLASS_TYPEAHEAD, " a"), _typeaheadKeyBindings).on('click', _closeTypeaheadOnBlur);
    }
    /**
     * _bindEvents - bind search form events
     *
     * Note: this method supports handling per individual search form component instances
     */


function _bindEvents() {
        $(CLASS_INPUT).on('blur focus', _handleSearchFieldFocusChange); // TODO: probably need to move 'IS_RESULTS_PAGE' flag into AEM as component config

        if (!IS_RESULTS_PAGE) {
            // submit search form only if not already on search results page
            $(document).on('submit', '.search-form', _handleFormSubmission);
        }
    }
    /**
     * _openDrawer - opens up the search drawer.
     */


function _openDrawer(e) {
        var $searchWrapper = $(e.target).closest('.header-wrap');
        var $searchOverlay = $searchWrapper.find(".".concat(CLASS_CTA_SEARCH_OVERLAYS));
        var $searchContainer = $searchOverlay.siblings('.search-form-container');
        var $searchinput = $searchContainer.find(CLASS_INPUT);
        $searchContainer.addClass(CLASS_DRAWER_OPEN);
        $searchinput.focus();
        $searchOverlay.addClass(CLASS_DRAWER_OPEN);
        $body.addClass(CLASS_NO_SCROLL);
        $(".".concat(CLASS_CTA_SEARCH_OPEN)).attr('aria-expanded', true);
        set('searchbar', $searchContainer);
    }
    /**
     * _closeDrawer - close the search drawer
     */


function _closeDrawer(e) {
        var $searchWrapper = $(e.target).closest('.header-wrap');
        var $searchOverlay = $searchWrapper.find(".".concat(CLASS_CTA_SEARCH_OVERLAYS));
        var $searchContainer = $searchOverlay.siblings('.search-form-container');
        var $searchOpenButton = $searchWrapper.find('.cta-search-form-open');
        $searchContainer.removeClass(CLASS_DRAWER_OPEN);
        $searchOpenButton.focus();
        $searchOverlay.removeClass(CLASS_DRAWER_OPEN);
        $body.removeClass(CLASS_NO_SCROLL);
        $(".".concat(CLASS_CTA_SEARCH_OPEN)).attr('aria-expanded', false);
        unset('searchbar', $searchContainer);
        return false;
    }
    /**
     * _initDrawer - set up various bindings to control the search drawer.
     *
     * Note: this method assumes there's only one instance of search form component that's coupled with top nav
     */


function _initDrawer() {
    // if you click on the search button, open the search modal.
    $(".".concat(CLASS_CTA_SEARCH_OPEN)).on('click', function(e) {
        return _openDrawer(e);
    });
    $(".".concat(CLASS_CTA_SEARCH_CLOSE)).on('click', function(e) {
        return _closeDrawer(e);
    });
    $(".".concat(CLASS_CTA_SEARCH_OVERLAYS)).on('click', function(e) {
        return _closeDrawer(e);
    });
}

function _prepInstancesAndData() {
    var $allSearchInputs = $(CLASS_INPUT); // Populate instance level global data array for all instances

    $allSearchInputs.each(function(idx, ele) {
        var $input = $(ele);
        var instanceId = idx + 1;
        var autoSuggestEndpoint = $input.attr('data-api-base') || '';
        var instanceData = {
            id: instanceId,
            autoSuggestEndpoint: autoSuggestEndpoint,
            autoSuggestPromise: null,
            autoSuggestData: null
        }; // update global instances data list

        _instancesData.push(instanceData); // update instance id to view


        var autoSuggestListId = "search-form-auto-suggestions-".concat(instanceId);
        var $autoSuggestList = $input.closest(CLASS_WRAPPER).find("".concat(CLASS_TYPEAHEAD, " > ul"));
        $input.attr({
            'data-instance-id': instanceId,
            'aria-owns': autoSuggestListId
        });
        $autoSuggestList.attr('id', autoSuggestListId); // check auto suggest pool endpoint

        if (!autoSuggestEndpoint.length) {
            console.warn('[SF]', 'Invalid auto suggest data endpoint for instance:', instanceId, autoSuggestEndpoint);
            return;
        } // check if current instance's endpoint is the same as previous one to save unnecessary remote calls


        for (var i = idx; i > 0; i--) {
            var previousInstanceIndex = idx - 1;
            var previousInstanceData = _instancesData[previousInstanceIndex] || {};
            var previousInstanceAutoSuggestEndpoint = previousInstanceData.autoSuggestEndpoint;

            if (autoSuggestEndpoint.length && autoSuggestEndpoint === previousInstanceAutoSuggestEndpoint) {
                // reference to previous auto suggest request promise if endpoint matches
                instanceData.autoSuggestPromise = previousInstanceData.autoSuggestPromise;
            }
        } // if no same endpoint request found from other instances, create new


        if (instanceData.autoSuggestPromise === null) {
            instanceData.autoSuggestPromise = $.get(autoSuggestEndpoint);
        } // retrieve basic auto suggest results pool data


        instanceData.autoSuggestPromise.done(function(dataString) {
            if (typeof dataString !== 'string') {
                console.warn('[SF]', 'Invalid auto suggest data string:', instanceId, dataString);
                return;
            } // Note: S&P auto complete data source returns in deprecated JSONP string format,
            // need clean-up before parse it


            var jsonString = dataString.trim().slice(1, -1);

            try {
                instanceData.autoSuggestData = JSON.parse(jsonString.trim());
            } catch (e) {
                instanceData.autoSuggestData = null;
                console.warn('[SF]', 'Invalid auto suggest JSON string:', instanceId, jsonString, e);
            }
        }).fail(function() {
            console.warn('[SF]', 'Error getting auto suggest results pool data', instanceId);
        });
    });
}

function init() {
    var _$;

    _bindEvents();

    _initDrawer(); // update individual instance element DOM and prep instance data
    // this will get '_instancesData' list ready


    _prepInstancesAndData(); // only init type ahead when all instances have resolve their remote requests


    var allInstancesPromises = [];

    _instancesData.forEach(function(instanceData) {
        if (instanceData.autoSuggestPromise !== null) {
            allInstancesPromises.push(instanceData.autoSuggestPromise);
        }
    });

    (_$ = $).when.apply(_$, allInstancesPromises).then(function() {
        _initTypeahead();
    });
}

$(document).ready(function() {
    init();
}); //# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://aem-cms-code/./ui.frontend/src/main/global/js/variables/constants.js?ae1c","webpack://aem-cms-code/./ui.frontend/src/main/global/js/helpers/debounce.js?d017","webpack://aem-cms-code/./ui.frontend/src/main/global/js/helpers/restrictFocus.js?73d6","webpack://aem-cms-code/./ui.apps/src/main/content/jcr_root/apps/global/components/corp-site/search/search-form-component/clientlib/src/js/search-form-component.js?19b6"],"names":["CONSTANTS","HASH_CHAR_LIMIT","CLASSES","HIDDEN","ACTIVE","CURRENT","FOCUSED","ERROR","OPEN","DISABLED","HAS_ERROR","KEYBOARD","BACKSPACE","TAB","ENTER","ESCAPE","LEFT","UP","RIGHT","DOWN","DELETE","FORWARD_SLASH","ATTRIBUTES","READONLY","REQUIRED","MAX","MIN","BREAKPOINTS","XSM","SM","MD","LG","XL","XXL","debounce","func","wait","timeout","args","context","timestamp","debouncedFunc","last","slice","call","arguments","Date","setTimeout","apply","set","namespace","$container","eventType","attr","$","document","on","event","contains","target","stopPropagation","focus","unset","off","KEYCODE_TAB","KEYCODE_ENTER","KEYCODE_ESCAPE","KEYCODE_UP","KEYCODE_DOWN","CLASS_WRAPPER","CLASS_INPUT","CLASS_TYPEAHEAD","IS_RESULTS_PAGE","hasClass","CHAR_THRESHOLD","AUTO_SUGGEST_DEBOUNCE_WAIT","CLASS_DRAWER_OPEN","CLASS_NO_SCROLL","CLASS_CTA_SEARCH_OPEN","CLASS_CTA_SEARCH_CLOSE","CLASS_CTA_SEARCH_OVERLAYS","$body","_instancesData","_updateTypeahead","data","$input","results","length","resultsList","$typeahead","siblings","formAction","parents","listHtml","i","suggestion","encodedSuggestion","encodeURI","link","removeClass","find","html","_clearTypeahead","addClass","empty","_getMatchingSuggestionsList","inputValue","maxSuggestCount","instanceId","parseInt","instanceData","autoSuggestPoolData","autoSuggestData","matchingSuggestions","toLowerCase","indexOf","trim","push","_findSuggestions","suggestionsData","_keyboardNavigation","inputIsFocussed","is","$suggestions","numSuggestions","inArray","keyCode","selectIndex","_updateSelectedSuggestion","window","location","currentTarget","href","currentIndex","index","indexOffset","shiftKey","each","idx","ele","$suggestion","$suggestionWrapper","parent","_inputKeyBindings","value","_inputNavBindings","_typeaheadKeyBindings","closest","_handleFormSubmission","$form","query","val","encodeURIComponent","_handleSearchFieldFocusChange","$inputWrapper","type","_closeTypeaheadOnBlur","clickedOutsideSearchForm","$element","_initTypeahead","e","_bindEvents","_openDrawer","$searchWrapper","$searchOverlay","$searchContainer","$searchinput","setRestrictFocus","_closeDrawer","$searchOpenButton","unsetRestrictFocus","_initDrawer","_prepInstancesAndData","$allSearchInputs","autoSuggestEndpoint","id","autoSuggestPromise","autoSuggestListId","$autoSuggestList","console","warn","previousInstanceIndex","previousInstanceData","previousInstanceAutoSuggestEndpoint","get","done","dataString","jsonString","JSON","parse","fail","init","allInstancesPromises","forEach","when","then","ready"],"mappings":"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","file":"7876.js","sourcesContent":["export const CONSTANTS = {\n  HASH_CHAR_LIMIT: 50,\n\n  CLASSES: {\n    HIDDEN: 'is-hidden',\n    ACTIVE: 'is-active',\n    CURRENT: 'is-current',\n    FOCUSED: 'is-focused',\n    ERROR: 'is-error',\n    OPEN: 'is-open',\n    DISABLED: 'is-disabled',\n    HAS_ERROR: 'has-error'\n  },\n\n  KEYBOARD: {\n    BACKSPACE: 8,\n    TAB: 9,\n    ENTER: 13,\n    ESCAPE: 27,\n    LEFT: 37,\n    UP: 38,\n    RIGHT: 39,\n    DOWN: 40,\n    DELETE: 46,\n    FORWARD_SLASH: 191\n  },\n\n  ATTRIBUTES: {\n    DISABLED: 'disabled',\n    READONLY: 'readonly',\n    REQUIRED: 'required',\n    MAX: 'max',\n    MIN: 'min'\n  },\n\n  BREAKPOINTS: {\n    XSM: 0,\n    SM: 480,\n    MD: 680,\n    LG: 970,\n    XL: 1170,\n    XXL: 1600\n  }\n};\n","/**\n * debounce - Debounce helper method\n * Based on https://github.com/rhysbrettbowen/debounce/blob/master/debounce.js\n *\n * @param  {Function} func  target function to be called\n * @param  {string} wait    wait time after the last call of target function before it is called\n * @return {Function}\n */\nexport function debounce(func, wait) {\n  // we need to save these in the closure\n  var timeout, args, context, timestamp;\n\n  return function() {\n    var debouncedFunc, last;\n\n    // save details of latest call\n    context = this;\n    args = [].slice.call(arguments, 0);\n    timestamp = new Date();\n\n    // this is where the magic happens\n    debouncedFunc = function() {\n      // how long ago was the last call\n      last = (new Date()) - timestamp;\n\n      // if the latest call was less that the wait period ago\n      // then we reset the timeout to wait for the difference\n      if (last < wait) {\n        timeout = setTimeout(debouncedFunc, wait - last);\n      } else {\n        // or if not we can null out the timer and run the latest\n        timeout = null;\n        func.apply(context, args);\n      }\n    };\n\n    // we only need to set the timer now if one isn't already running\n    if (!timeout) {\n      timeout = setTimeout(debouncedFunc, wait);\n    }\n  }\n}\n","export function set(namespace, $container) {\n  var eventType = 'focusin.' + namespace;\n\n  $container.attr('tabindex', '0');\n\n  $(document).on(eventType, function(event) {\n    if (!$container[0].contains(event.target)) {\n      event.stopPropagation();\n      $container.focus();\n    }\n  });\n}\n\nexport function unset(namespace, $container) {\n  var eventType = 'focusin.' + namespace;\n\n  $container.attr('tabindex', '-1');\n\n  $(document).off(eventType);\n}\n","import { CONSTANTS } from 'Constants/constants';\nimport { debounce } from 'Helpers/debounce';\nimport { set as setRestrictFocus, unset as unsetRestrictFocus } from 'Helpers/restrictFocus';\n\n// type ahead keys\nconst KEYCODE_TAB = CONSTANTS.KEYBOARD.TAB;\nconst KEYCODE_ENTER = CONSTANTS.KEYBOARD.ENTER;\nconst KEYCODE_ESCAPE = CONSTANTS.KEYBOARD.ESCAPE;\nconst KEYCODE_UP = CONSTANTS.KEYBOARD.UP;\nconst KEYCODE_DOWN = CONSTANTS.KEYBOARD.DOWN;\n\n// type ahead classes and states\nconst CLASS_WRAPPER = '.js-search-form-input-wrap';\nconst CLASS_INPUT = '.js-search-form-input';\nconst CLASS_TYPEAHEAD = '.search-typeahead';\nconst IS_RESULTS_PAGE = $('.wrapper-body').hasClass('has-search-results');\nconst CHAR_THRESHOLD = 3;\nconst AUTO_SUGGEST_DEBOUNCE_WAIT = 200;\n\n// search drawer classes\nconst CLASS_DRAWER_OPEN = 'is-open';\nconst CLASS_NO_SCROLL = 'no-scroll';\n\n// search drawer view elements\nconst CLASS_CTA_SEARCH_OPEN = 'cta-search-form-open';\nconst CLASS_CTA_SEARCH_CLOSE = 'cta-search-form-close';\nconst CLASS_CTA_SEARCH_OVERLAYS = 'search-overlay';\nconst $body = $('body');\n\n// List holding instance level global data for all instances\nconst _instancesData = [];\n\n/**\n * _updateTypeahead - takes data from the suggestions api and updates the dom with results as\n *                    well as making the typeahead visible.\n *\n * @param  {object} data   object containing raw results from the api\n * @param  {object} $input jQuery object representing the current input in use.\n */\nfunction _updateTypeahead(data, $input) {\n  if (data && data.results && data.results.length) {\n    const resultsList = data.results;\n    const $typeahead = $input.siblings(CLASS_TYPEAHEAD);\n    const formAction = $input.parents('form').attr('action');\n    let listHtml = '';\n\n    for (let i = 0; i < resultsList.length; i++) {\n      // build the html to add to the dom.\n      const suggestion = resultsList[i];\n      const encodedSuggestion = encodeURI(suggestion);\n      const link = `${formAction}?q=${encodedSuggestion}&ref=auto`;\n\n      listHtml += `<li role=\"option\" aria-selected=\"false\"><a href=\"${link}\" data-query=\"${suggestion}\" title=\"Search for ${suggestion}\">${suggestion}</a></li>\\n`;\n    }\n\n    $typeahead\n      .removeClass('is-hidden')\n      .attr('aria-expanded', true)\n      .find('ul')\n      .html(listHtml);\n  } else {\n    // if there are no suggestions clear the typeahead ui.\n    _clearTypeahead($input);\n  }\n}\n\n/**\n * _clearTypeahead - clears the typeahead results and hides it.\n *\n * @param  {object} $input jQuery object representing the current input in use.\n * @return {Boolean}       allow event to propagate.\n */\nfunction _clearTypeahead($input) {\n  const $typeahead = $input.siblings(CLASS_TYPEAHEAD);\n\n  $typeahead\n    .addClass('is-hidden')\n    .attr('aria-expanded', false)\n    .find('ul')\n    .empty();\n\n  return true;\n}\n\n/**\n * _getMatchingSuggestionsList - creates a list of matching suggestions from the data pool\n *\n * @param {String} inputValue  the value of the input as a trimmed string\n * @param {Object} $input  the $input element jQuery object\n * @returns {Array}  list of matching suggestions from input query against auto suggest result data pool\n */\nfunction _getMatchingSuggestionsList(inputValue, $input) {\n  const maxSuggestCount = $input.attr('data-max-suggestions');\n  const instanceId = parseInt($input.attr('data-instance-id'), 10);\n  const instanceData = _instancesData[instanceId - 1] || {};\n  const autoSuggestPoolData = instanceData.autoSuggestData || [];\n  const matchingSuggestions = [];\n\n  for (let i = 0; i < autoSuggestPoolData.length; i++) {\n    const suggestion = autoSuggestPoolData[i];\n    if (suggestion.toLowerCase().indexOf(inputValue.trim().toLowerCase()) === 0) {\n      matchingSuggestions.push(suggestion);\n      if (matchingSuggestions.length >= maxSuggestCount) {\n        break;\n      }\n    }\n  }\n\n  return matchingSuggestions;\n}\n\n/**\n * _findSuggestions - makes the request to the suggestions api and acts accordingly through\n *                    callback functions.\n *\n * @param  {String} inputValue the value of the input as a trimmed string.\n * @param  {object} $input jQuery object representing the current input in use.\n */\nfunction _findSuggestions(inputValue, $input) {\n  // TODO: update to get suggestion results list from S&P endpoint once the JSON feed is ready\n\n  // prep suggestion data for view updates\n  const suggestionsData = {\n    results: _getMatchingSuggestionsList(inputValue, $input),\n  };\n\n  // this function cleans up the typeahead if no results are returned or if an error has\n  // occurred, so no error callback is required.\n  _updateTypeahead(suggestionsData, $input);\n}\n\n/**\n * _keyboardNavigation - allows keyboard navigation through and out of the typeahead. this is\n *                       used by functions bound to both the input and the typeahead.\n *\n * @param  {object} $input     jQuery object representing the current input in use.\n * @param  {object} $typeahead jQuery object representing the current typeahead displayed.\n * @param  {object} event      the keydown event\n * @return {boolean}           prevent default event behaviour\n */\nfunction _keyboardNavigation($input, $typeahead, event) {\n  const inputIsFocussed = $input.is(':focus');\n  const $suggestions = $typeahead.find('a');\n  const numSuggestions = $suggestions.length;\n\n  // if the input focussed jump to either end of the typeahead suggestions.\n  if (inputIsFocussed && $.inArray(event.keyCode, [KEYCODE_UP,\n    KEYCODE_DOWN]) > -1) {\n    const selectIndex = (event.keyCode === KEYCODE_DOWN) ? 0 : numSuggestions - 1;\n    _updateSelectedSuggestion($suggestions, selectIndex);\n    return false;\n\n  // if the user hits enter on a typeahead suggestion, redirect them to the search results, as\n  // long as they aren't currently on the results page.\n  } if (event.keyCode === KEYCODE_ENTER && !IS_RESULTS_PAGE && !inputIsFocussed) {\n    window.location = event.currentTarget.href;\n    return false;\n\n  // if they are using arrow or tab navigation move them to the next appropriate result.\n  } if ($.inArray(event.keyCode, [KEYCODE_TAB,\n    KEYCODE_UP,\n    KEYCODE_DOWN]) > -1) {\n    const currentIndex = $suggestions.index(event.currentTarget);\n    // go down an index for up arrow or shift-tab, otherwise up.\n    const indexOffset = (event.keyCode === KEYCODE_UP\n                      || (event.shiftKey && event.keyCode === KEYCODE_TAB)) ? -1 : 1;\n    const selectIndex = currentIndex + indexOffset;\n\n    if (selectIndex === -1 || selectIndex === numSuggestions) {\n      // if not an index within the range focus the input\n      $input.focus();\n      _updateSelectedSuggestion($suggestions);\n    } else {\n      // otherwise navigate the typeahead.\n      _updateSelectedSuggestion($suggestions, selectIndex);\n    }\n\n    return false;\n  } if (!inputIsFocussed && event.keyCode === KEYCODE_ESCAPE) {\n    $input.focus();\n    return _clearTypeahead($input);\n  }\n}\n\n/**\n * _updateSelectedSuggestion - update auto suggestion item selected states on view\n *\n * @param  {object} $suggestions  jquery collection of all suggestion anchor items\n * @param  {object} selectIndex  current selected item index\n * @return {void}\n */\nfunction _updateSelectedSuggestion($suggestions, selectIndex = -1) {\n  $suggestions.each((idx, ele) => {\n    const $suggestion = $(ele);\n    const $suggestionWrapper = $suggestion.parent('li');\n    if (idx === selectIndex) {\n      $suggestion.focus();\n      $suggestionWrapper.attr('aria-selected', 'true');\n    } else {\n      $suggestionWrapper.attr('aria-selected', 'false');\n    }\n  });\n}\n\n/**\n * _inputKeyBindings - monitor keyboard events on the search input and trigger appropriate behaviour.\n *\n * @param  {object} event   the keyup event.\n */\nfunction _inputKeyBindings(event) {\n  const $input = $(event.currentTarget);\n  const inputValue = event.currentTarget.value.trim();\n\n  // prevent arrow keys from keyboard nav from re-rendering the suggestions.\n  if ($.inArray(event.keyCode, [KEYCODE_ENTER,\n    KEYCODE_TAB,\n    KEYCODE_UP,\n    KEYCODE_DOWN]) > -1) {\n    return;\n  }\n\n  if (inputValue.length >= CHAR_THRESHOLD) {\n    // try to provide suggestions in the typeahead dropdown\n    _findSuggestions(inputValue, $input);\n  } else {\n    // clean up and close the typeahead.\n    return _clearTypeahead($input);\n  }\n}\n\n/**\n * _inputNavBindings - allow the user to enter the typeahead using arrow keys.\n *\n * @param  {object} event   the keydown event.\n * @return {boolean}        prevent default behaviour.\n */\nfunction _inputNavBindings(event) {\n  const $input = $(event.currentTarget);\n  const $typeahead = $input.siblings(CLASS_TYPEAHEAD);\n\n  // up and down arrows will enter the typeahead.\n  if ($.inArray(event.keyCode, [KEYCODE_ESCAPE,\n    KEYCODE_ENTER,\n    KEYCODE_UP,\n    KEYCODE_DOWN]) > -1) {\n    // if the typeahead isn't visible, don't hijack the keyboard.\n    if (!$typeahead.is(':visible')) {\n      return;\n    }\n\n    // keyboard navigation into and out of typeahead from input.\n    return _keyboardNavigation($input, $typeahead, event);\n  }\n}\n\n/**\n * _typeaheadKeyBindings - setting up handling of keyboard navigation within the typeahead.\n *\n * @param  {object} event   the keydown event.\n */\nfunction _typeaheadKeyBindings(event) {\n  const $typeahead = $(event.currentTarget).closest(CLASS_TYPEAHEAD);\n  const $input = $typeahead.siblings(CLASS_INPUT);\n\n  return _keyboardNavigation($input, $typeahead, event);\n}\n\n/**\n * _handleFormSubmission - hijacks the form submission so the query string can be uri encoded\n *                         before being manually redirected to the results page.\n *\n * @param  {object} event  the submit event\n * @return {boolean}  prevent default form submission.\n */\nfunction _handleFormSubmission(event) {\n  const $form = $(event.target);\n  const $input = $form.find(CLASS_INPUT);\n  const query = $input.val().trim();\n  window.location = `${$form.attr('action')}?q=${encodeURIComponent(query)}`;\n\n  return false;\n}\n\n/**\n * _handleSearchFieldFocusChange - update presentational focus state when search field focus state changes\n *\n * @param  {object} event  the focus change events\n * @return {void}\n */\nfunction _handleSearchFieldFocusChange(event) {\n  const $inputWrapper = $(event.target).closest(CLASS_WRAPPER);\n  if (event.type === 'focus') {\n    $inputWrapper.addClass(CONSTANTS.CLASSES.FOCUSED);\n  } else if (event.type === 'blur') {\n    $inputWrapper.removeClass(CONSTANTS.CLASSES.FOCUSED);\n  }\n}\n\n/**\n * _closeTypeaheadOnBlur - dismiss all typeaheads when click out of the search input\n *\n * @return {boolean}  do not prevent propagation.\n */\nfunction _closeTypeaheadOnBlur(event) {\n  const clickedOutsideSearchForm = !$(event.target).closest(CLASS_WRAPPER).length;\n\n  if (clickedOutsideSearchForm) {\n    $(`${CLASS_INPUT}[data-typeahead=true]`).each(($element) => {\n      _clearTypeahead($($element));\n    });\n  }\n\n  return true;\n}\n\n/**\n * _initTypeahead - set up various event bindings to control the typeahead.\n */\nfunction _initTypeahead() {\n  $(document)\n    // bind to key events on the inputs.\n    .on('input', `${CLASS_INPUT}[data-typeahead=true]`, debounce(_inputKeyBindings, AUTO_SUGGEST_DEBOUNCE_WAIT))\n    .on('keydown', `${CLASS_INPUT}[data-typeahead=true]`, _inputNavBindings)\n    .on('internal-search', `${CLASS_INPUT}[data-typeahead=true]`, (e) => {\n      _clearTypeahead($(e.target));\n    })\n\n    // bind key events to the typeahead anchors.\n    .on('keydown', `${CLASS_TYPEAHEAD} a`, _typeaheadKeyBindings)\n    .on('click', _closeTypeaheadOnBlur);\n}\n\n/**\n * _bindEvents - bind search form events\n *\n * Note: this method supports handling per individual search form component instances\n */\nfunction _bindEvents() {\n  $(CLASS_INPUT).on('blur focus', _handleSearchFieldFocusChange);\n\n  // TODO: probably need to move 'IS_RESULTS_PAGE' flag into AEM as component config\n  if (!IS_RESULTS_PAGE) {\n    // submit search form only if not already on search results page\n    $(document).on('submit', '.search-form', _handleFormSubmission);\n  }\n}\n\n/**\n * _openDrawer - opens up the search drawer.\n */\nfunction _openDrawer(e) {\n  const $searchWrapper = $(e.target).closest('.header-wrap');\n  const $searchOverlay = $searchWrapper.find(`.${CLASS_CTA_SEARCH_OVERLAYS}`);\n  const $searchContainer = $searchOverlay.siblings('.search-form-container');\n  const $searchinput = $searchContainer.find(CLASS_INPUT);\n\n  $searchContainer.addClass(CLASS_DRAWER_OPEN);\n  $searchinput.focus();\n  $searchOverlay.addClass(CLASS_DRAWER_OPEN);\n  $body.addClass(CLASS_NO_SCROLL);\n  $(`.${CLASS_CTA_SEARCH_OPEN}`).attr('aria-expanded', true);\n  setRestrictFocus('searchbar', $searchContainer);\n}\n\n/**\n * _closeDrawer - close the search drawer\n */\nfunction _closeDrawer(e) {\n  const $searchWrapper = $(e.target).closest('.header-wrap');\n  const $searchOverlay = $searchWrapper.find(`.${CLASS_CTA_SEARCH_OVERLAYS}`);\n  const $searchContainer = $searchOverlay.siblings('.search-form-container');\n  const $searchOpenButton = $searchWrapper.find('.cta-search-form-open');\n\n  $searchContainer.removeClass(CLASS_DRAWER_OPEN);\n  $searchOpenButton.focus();\n  $searchOverlay.removeClass(CLASS_DRAWER_OPEN);\n  $body.removeClass(CLASS_NO_SCROLL);\n  $(`.${CLASS_CTA_SEARCH_OPEN}`).attr('aria-expanded', false);\n  unsetRestrictFocus('searchbar', $searchContainer);\n  return false;\n}\n\n/**\n * _initDrawer - set up various bindings to control the search drawer.\n *\n * Note: this method assumes there's only one instance of search form component that's coupled with top nav\n */\nfunction _initDrawer() {\n  // if you click on the search button, open the search modal.\n  $(`.${CLASS_CTA_SEARCH_OPEN}`).on('click', (e) => _openDrawer(e));\n  $(`.${CLASS_CTA_SEARCH_CLOSE}`).on('click', (e) => _closeDrawer(e));\n  $(`.${CLASS_CTA_SEARCH_OVERLAYS}`).on('click', (e) => _closeDrawer(e));\n}\n\nfunction _prepInstancesAndData() {\n  const $allSearchInputs = $(CLASS_INPUT);\n\n  // Populate instance level global data array for all instances\n  $allSearchInputs.each((idx, ele) => {\n    const $input = $(ele);\n    const instanceId = idx + 1;\n    const autoSuggestEndpoint = $input.attr('data-api-base') || '';\n    const instanceData = {\n      id: instanceId,\n      autoSuggestEndpoint,\n      autoSuggestPromise: null,\n      autoSuggestData: null,\n    };\n\n    // update global instances data list\n    _instancesData.push(instanceData);\n\n    // update instance id to view\n    const autoSuggestListId = `search-form-auto-suggestions-${instanceId}`;\n    const $autoSuggestList = $input.closest(CLASS_WRAPPER).find(`${CLASS_TYPEAHEAD} > ul`);\n    $input\n      .attr({\n        'data-instance-id': instanceId,\n        'aria-owns': autoSuggestListId,\n      });\n    $autoSuggestList.attr('id', autoSuggestListId);\n\n    // check auto suggest pool endpoint\n    if (!autoSuggestEndpoint.length) {\n      console.warn('[SF]', 'Invalid auto suggest data endpoint for instance:', instanceId, autoSuggestEndpoint);\n      return;\n    }\n\n    // check if current instance's endpoint is the same as previous one to save unnecessary remote calls\n    for (let i = idx; i > 0; i--) {\n      const previousInstanceIndex = idx - 1;\n      const previousInstanceData = _instancesData[previousInstanceIndex] || {};\n      const previousInstanceAutoSuggestEndpoint = previousInstanceData.autoSuggestEndpoint;\n      if (autoSuggestEndpoint.length && autoSuggestEndpoint === previousInstanceAutoSuggestEndpoint) {\n        // reference to previous auto suggest request promise if endpoint matches\n        instanceData.autoSuggestPromise = previousInstanceData.autoSuggestPromise;\n      }\n    }\n\n    // if no same endpoint request found from other instances, create new\n    if (instanceData.autoSuggestPromise === null) {\n      instanceData.autoSuggestPromise = $.get(autoSuggestEndpoint);\n    }\n\n    // retrieve basic auto suggest results pool data\n    instanceData.autoSuggestPromise\n      .done((dataString) => {\n        if (typeof dataString !== 'string') {\n          console.warn('[SF]', 'Invalid auto suggest data string:', instanceId, dataString);\n          return;\n        }\n\n        // Note: S&P auto complete data source returns in deprecated JSONP string format,\n        // need clean-up before parse it\n        const jsonString = dataString.trim().slice(1, -1);\n        try {\n          instanceData.autoSuggestData = JSON.parse(jsonString.trim());\n        } catch (e) {\n          instanceData.autoSuggestData = null;\n          console.warn('[SF]', 'Invalid auto suggest JSON string:', instanceId, jsonString, e);\n        }\n      })\n      .fail(() => {\n        console.warn('[SF]', 'Error getting auto suggest results pool data', instanceId);\n      });\n  });\n}\n\nfunction init() {\n  _bindEvents();\n  _initDrawer();\n\n  // update individual instance element DOM and prep instance data\n  // this will get '_instancesData' list ready\n  _prepInstancesAndData();\n\n  // only init type ahead when all instances have resolve their remote requests\n  const allInstancesPromises = [];\n  _instancesData.forEach((instanceData) => {\n    if (instanceData.autoSuggestPromise !== null) {\n      allInstancesPromises.push(instanceData.autoSuggestPromise);\n    }\n  });\n  $.when(...allInstancesPromises).then(() => {\n    _initTypeahead();\n  });\n}\n\n$(document).ready(() => {\n  init();\n});\n"],"sourceRoot":""}
//# sourceURL=webpack-internal:///7876

// EXTERNAL MODULE: ./node_modules/picturefill/dist/picturefill.js
var picturefill = __webpack_require__(7229);; // CONCATENATED MODULE: ./ui.frontend/src/main/global/js/polyfills/objectFit.js
/* eslint-disable no-undef */
function objectFit() {
    // Constants
    var CLASS_OBJECT_FIT = 'js-object-fit';
    /**
     * _parseSourceset($context)
     *
     * @param {jQuery} $source   - source item as jquery object
     * @return {string} source - best path available in the srcset for the current source item
     */

    function _parseSourceset($source) {
            var source = false;

            if (window.matchMedia($source.attr('media')).matches) {
                var srcset = $source.attr('srcset');
                var regEx = new RegExp(' [0-9]+w$');
                source = srcset.replace(regEx, '');
            }

            return source;
        }
        /**
         * retrieveSource($img, isPicture)
         *
         * @param {jQuery} $img       - current image with the class js-object-it
         * @param {boolean} isPicture  - if the image is inside a picture tag or not
         * @return {String}            - the best available source for the current image
         */


    function _retrieveSource($img, isPicture) {
            // if srcset feature is available
            // just return the current source used
            if (Modernizr.srcset) {
                return $img[0].currentSrc;
            } // if it's a picture tag and the srcset feature does not work
            // parse the source nodes to find the best value possible


            if (isPicture) {
                var $sources = $img.parent().find('source');
                var source = false;
                $sources.each(function() {
                    source = source || _parseSourceset($(this));
                });

                if (source) {
                    return source;
                }
            } // or just return the src attribute from the image tag


            return $img.prop('src');
        }
        /**
         * _init()
         *
         * if you place the class .js-object-fit on an <img> element which uses the object-fit css
         * property, this polyfill will replace the element with a div and use background styles to
         * emulate the appearance. this works within a <picture> element too, as long as the classes are
         * placed on the <img> within it.
         */


    function init() {
        if (Modernizr && Modernizr.objectfit) {
            return;
        }

        $(".".concat(CLASS_OBJECT_FIT)).each(function() {
            var $node = $(this);
            var $img;
            var $picture;
            var isAdaptiveImg = $node.hasClass('adpimg__container');

            if (isAdaptiveImg) {
                // Adaptive image
                $img = $node.find('img');
                $picture = $node.find('picture');
            } else {
                // img tag with js-object-fit
                $img = $node;
                $picture = $node.parent('picture');
            }

            var isPicture = $picture.length;

            var imgCurrentSrc = _retrieveSource($img, isPicture);

            var imgClasses = $img.attr('class');
            var $nodeToReplace = isPicture ? $picture : $img; // create the new dom node.

            var $newNode = $('<div>').css({
                backgroundImage: "url(".concat(imgCurrentSrc, ")")
            }).addClass("".concat(imgClasses, " polyfill-object-fit")).removeClass(CLASS_OBJECT_FIT); // Remove class from adaptive image container

            if (isAdaptiveImg) {
                $node.removeClass(CLASS_OBJECT_FIT);
            } // setup a min-height in case the image is providing the height for it's parent.


            if (isPicture) {
                $newNode.css({
                    minHeight: $img.height(),
                    minWidth: $img.width()
                });
            } // replace the img element.


            $nodeToReplace.replaceWith($newNode);
        });
    }

    return init();
}; // CONCATENATED MODULE: ./ui.apps/src/main/content/jcr_root/apps/global/components/picture/clientlib/src/js/picture.js
// NOTE: Consider whether this should be integrated with Modernizr


window.addEventListener('load', function() {
    objectFit();
}); //# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://aem-cms-code/./ui.frontend/src/main/global/js/polyfills/objectFit.js?4425","webpack://aem-cms-code/./ui.apps/src/main/content/jcr_root/apps/global/components/picture/clientlib/src/js/picture.js?c42c"],"names":["objectFit","CLASS_OBJECT_FIT","_parseSourceset","$source","source","window","matchMedia","attr","matches","srcset","regEx","RegExp","replace","_retrieveSource","$img","isPicture","Modernizr","currentSrc","$sources","parent","find","each","$","prop","init","objectfit","$node","$picture","isAdaptiveImg","hasClass","length","imgCurrentSrc","imgClasses","$nodeToReplace","$newNode","css","backgroundImage","addClass","removeClass","minHeight","height","minWidth","width","replaceWith","addEventListener"],"mappings":"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","file":"5702.js","sourcesContent":["/* eslint-disable no-undef */\nexport function objectFit() {\n  // Constants\n  const CLASS_OBJECT_FIT = 'js-object-fit';\n\n  /**\n   * _parseSourceset($context)\n   *\n   * @param {jQuery} $source   - source item as jquery object\n   * @return {string} source - best path available in the srcset for the current source item\n   */\n  function _parseSourceset($source) {\n    let source = false;\n\n    if (window.matchMedia($source.attr('media')).matches) {\n      const srcset = $source.attr('srcset');\n      const regEx = new RegExp(' [0-9]+w$');\n      source = srcset.replace(regEx, '');\n    }\n\n    return source;\n  }\n\n  /**\n   * retrieveSource($img, isPicture)\n   *\n   * @param {jQuery} $img       - current image with the class js-object-it\n   * @param {boolean} isPicture  - if the image is inside a picture tag or not\n   * @return {String}            - the best available source for the current image\n   */\n  function _retrieveSource($img, isPicture) {\n    // if srcset feature is available\n    // just return the current source used\n    if (Modernizr.srcset) {\n      return $img[0].currentSrc;\n    }\n\n    // if it's a picture tag and the srcset feature does not work\n    // parse the source nodes to find the best value possible\n    if (isPicture) {\n      const $sources = $img.parent().find('source');\n      let source = false;\n      $sources.each(function () {\n        source = source || _parseSourceset($(this));\n      });\n\n      if (source) {\n        return source;\n      }\n    }\n\n    // or just return the src attribute from the image tag\n    return $img.prop('src');\n  }\n\n  /**\n   * _init()\n   *\n   * if you place the class .js-object-fit on an <img> element which uses the object-fit css\n   * property, this polyfill will replace the element with a div and use background styles to\n   * emulate the appearance. this works within a <picture> element too, as long as the classes are\n   * placed on the <img> within it.\n   */\n  function init() {\n    if (Modernizr && Modernizr.objectfit) {\n      return;\n    }\n\n    $(`.${CLASS_OBJECT_FIT}`).each(function () {\n      const $node = $(this);\n      let $img;\n      let $picture;\n\n      const isAdaptiveImg = $node.hasClass('adpimg__container');\n      if (isAdaptiveImg) {\n        // Adaptive image\n        $img = $node.find('img');\n        $picture = $node.find('picture');\n      } else {\n        // img tag with js-object-fit\n        $img = $node;\n        $picture = $node.parent('picture');\n      }\n\n      const isPicture = $picture.length;\n      const imgCurrentSrc = _retrieveSource($img, isPicture);\n      const imgClasses = $img.attr('class');\n      const $nodeToReplace = (isPicture) ? $picture : $img;\n\n      // create the new dom node.\n      const $newNode = $('<div>').css({ backgroundImage: `url(${imgCurrentSrc})` })\n        .addClass(`${imgClasses} polyfill-object-fit`)\n        .removeClass(CLASS_OBJECT_FIT);\n\n      // Remove class from adaptive image container\n      if (isAdaptiveImg) {\n        $node.removeClass(CLASS_OBJECT_FIT);\n      }\n\n      // setup a min-height in case the image is providing the height for it's parent.\n      if (isPicture) {\n        $newNode.css({\n          minHeight: $img.height(),\n          minWidth: $img.width(),\n        });\n      }\n\n      // replace the img element.\n      $nodeToReplace.replaceWith($newNode);\n    });\n  }\n\n  return init();\n}\n","import 'picturefill'; // NOTE: Consider whether this should be integrated with Modernizr\nimport { objectFit } from 'Polyfills/objectFit';\n\nwindow.addEventListener('load', () => {\n  objectFit();\n});\n"],"sourceRoot":""}
//# sourceURL=webpack-internal:///5702

_satellite.setCookie("sat_track", "true");

if (true) {
    module.exports = __webpack_require__(53);
} else {}
//# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9hZW0tY21zLWNvZGUvLi9ub2RlX21vZHVsZXMvc2NoZWR1bGVyL2luZGV4LmpzPzQwMjkiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQWE7O0FBRWIsSUFBSSxJQUFxQztBQUN6QyxFQUFFLHdDQUE2RDtBQUMvRCxDQUFDLE1BQU0sRUFFTiIsImZpbGUiOiIzODQwLmpzIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5pZiAocHJvY2Vzcy5lbnYuTk9ERV9FTlYgPT09ICdwcm9kdWN0aW9uJykge1xuICBtb2R1bGUuZXhwb3J0cyA9IHJlcXVpcmUoJy4vY2pzL3NjaGVkdWxlci5wcm9kdWN0aW9uLm1pbi5qcycpO1xufSBlbHNlIHtcbiAgbW9kdWxlLmV4cG9ydHMgPSByZXF1aXJlKCcuL2Nqcy9zY2hlZHVsZXIuZGV2ZWxvcG1lbnQuanMnKTtcbn1cbiJdLCJzb3VyY2VSb290IjoiIn0=
//# sourceURL=webpack-internal:///3840

; // CONCATENATED MODULE: ./ui.frontend/src/main/global/js/helpers/restrictFocus.js
function set(namespace, $container) {
    var eventType = 'focusin.' + namespace;
    $container.attr('tabindex', '0');
    $(document).on(eventType, function(event) {
        if (!$container[0].contains(event.target)) {
            event.stopPropagation();
            $container.focus();
        }
    });
}

function unset(namespace, $container) {
    var eventType = 'focusin.' + namespace;
    $container.attr('tabindex', '-1');
    $(document).off(eventType);
}; // CONCATENATED MODULE: ./ui.frontend/src/main/global/js/variables/constants.js
var CONSTANTS = {
    HASH_CHAR_LIMIT: 50,
    CLASSES: {
        HIDDEN: 'is-hidden',
        ACTIVE: 'is-active',
        CURRENT: 'is-current',
        FOCUSED: 'is-focused',
        ERROR: 'is-error',
        OPEN: 'is-open',
        DISABLED: 'is-disabled',
        HAS_ERROR: 'has-error'
    },
    KEYBOARD: {
        BACKSPACE: 8,
        TAB: 9,
        ENTER: 13,
        ESCAPE: 27,
        LEFT: 37,
        UP: 38,
        RIGHT: 39,
        DOWN: 40,
        DELETE: 46,
        FORWARD_SLASH: 191
    },
    ATTRIBUTES: {
        DISABLED: 'disabled',
        READONLY: 'readonly',
        REQUIRED: 'required',
        MAX: 'max',
        MIN: 'min'
    },
    BREAKPOINTS: {
        XSM: 0,
        SM: 480,
        MD: 680,
        LG: 970,
        XL: 1170,
        XXL: 1600
    }
};; // CONCATENATED MODULE: ./ui.frontend/src/main/global/js/helpers/isMq.js


var mq = {
    xsm: 0,
    sm: 480,
    md: 680,
    lg: 970,
    xl: 1170,
    xxl: 1600
};

function isMq(min) {
    return window.matchMedia("(min-width: ".concat(mq[min], "px)"));
}

function isBetween(min, max) {
        return window.matchMedia("(min-width: ".concat(mq[min], "px) and (max-width: ").concat(mq[max] - 1, "px)"));
    } // example of how to use above
    // Ref: https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Testing_media_queries
    // apAEM.HELPERS.isMq('lg').addListener(function(){
    //     if (apAEM.HELPERS.isMq('lg').matches) {
    //         console.log('matches');
    //     } else {
    //         console.log('does not match');
    //     }
    // });
    // apAEM.HELPERS.isBetween('lg', 'xl').addListener(function(){
    //     if (apAEM.HELPERS.isBetween('lg', 'xl').matches) {
    //         console.log('matches');
    //     } else {
    //         console.log('does not match');
    //     }
    // });
; // CONCATENATED MODULE: ./ui.frontend/src/main/global/js/helpers/scrollTo.js

/**
 * scrollToTarget - scroll page to a position or a target element
 *
 * @param  {Object|Number} target        target to scroll page to, either be a scroll position or an jQuery object
 * @param  {Object} shouldScrollFromTop  whether should start scrolling from page top
 * @return {void}
 */

var scrollToTarget = function scrollToTarget(target) {
    var shouldScrollFromTop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    var speed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;
    var offset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
    var ATTR_SCROLLING = 'data-is-scrolling';
    var $body = $('body');
    var isScrolling = $body.attr(ATTR_SCROLLING) === 'true';

    if (isScrolling) {
        return false;
    } // check target type and determine target scroll position


    var targetPosition;
    var $target = $(target[0]);

    if (typeof $target === 'number') {
        targetPosition = Math.round(Math.abs($target));
    } else {
        var targetPositionNum = _getTargetScrollPosition($target);

        if (targetPositionNum) {
            targetPosition = targetPositionNum;
        } else {
            targetPosition = 0;
        }
    } // set page scroll to top


    var $page = $('html, body');

    if (shouldScrollFromTop) {
        $page.scrollTop(0);

        if (targetPosition === 0) {
            return false;
        }
    } // animate page scroll position


    $body.attr(ATTR_SCROLLING, 'true');
    $page.animate({
        scrollTop: targetPosition + offset
    }, speed, function() {
        $body.removeAttr(ATTR_SCROLLING);
    });
};
/**
 * _getTargetScrollPosition - returns target element's scroll position
 *
 * @param  {Object} $target  jQuery object of target to scroll page to
 * @return {number}
 */

var _getTargetScrollPosition = function _getTargetScrollPosition($target) {
    if (!$target || !$target.length) {
        return null;
    }

    var $subnav = $('.subnav[data-sticky-subnav="true"]');
    var $globalHeader = $('.global-header#header');
    var isMqLG = isMq('lg').matches;
    var adjustment = 0;

    if (isMqLG && $subnav.length) {
        adjustment = $subnav.height();
    } else if (!isMqLG && $globalHeader.length) {
        adjustment = $globalHeader.height();
    }

    return $($target[0]).offset().top - adjustment;
};; // CONCATENATED MODULE: ./ui.apps/src/main/content/jcr_root/apps/global/components/auspost/header-corporate/clientlib/src/js/import/nav.js


// analytics and satellite should be defined globally

analytics = analytics || {};
_satellite = _satellite || {};
analytics.component = analytics.component || {};
analytics.component.link = analytics.component.link || {};

_satellite.track = _satellite.track || function() {
    console.warn('_satellite.track is not defined');
};

var UUID_PREFIX = 'MM';
var CLASS_HEADER = '.global-header, .global-header-old';
var CLASS_PRIMARY_NAV = 'primary-nav';
var CLASS_MICROSITE_NAV = 'main-nav';
var CLASS_MICROSITE_NAV_LOGO_LINK = 'main-nav-logo-link';
var CLASS_PRIMARY_CONTAINER = 'pn-container';
var CLASS_PRIMARY_LIST = 'pn-list';
var CLASS_PRIMARY_ITEM = 'pn-item';
var CLASS_PRIMARY_LINK = 'pn-link';
var CLASS_PRIMARY_LOGIN_ITEM = 'pn-login';
var CLASS_PRIMARY_LINK_EXPANDABLE = 'pn-link--expandable';
var CLASS_PRIMARY_LINK_EXPANDABLE_LOCKED = 'pn-link--expandable-locked';
var CLASS_PRIMARY_TOOLS_LIST_CONTAINER = 'pn-tools-list-container';
var CLASS_PRIMARY_TOOLS_LIST = 'pn-link--tools';
var CLASS_PRIMARY_UTILITY_LIST_CONTAINER = 'pn-utility-list-container';
var CLASS_PRIMARY_UTILITY_LIST = 'pn-link--utility';
var CLASS_PRIMARY_TOGGLE = 'js-pn-toggle';
var CLASS_PRIMARY_TRIGGER_OPEN = 'pn-trigger-open';
var CLASS_PRIMARY_TRIGGER_CLOSE = 'js-pn-trigger-close-mobile';
var CLASS_SUBNAV_CONTAINER = 'sub-pn';
var CLASS_SUBNAV_EXPANDABLE = 'sub-pn--expandable';
var CLASS_SUBNAV_LIST = 'sub-pn-list';
var CLASS_SUBNAV_LINK = 'sub-pn-link';
var CLASS_OPEN = 'is-open';
var CLASS_ACTIVE = 'is-active';
var CLASS_TRANSITIONING = 'is-transitioning';
var CLASS_CLOSING = 'is-closing';
var CLASS_HOVER = 'is-hover';
var CLASS_FOCUS = 'is-focused';
var CLASS_NO_SCROLL = 'no-scroll';
var CLASS_HAS_CHILDREN = 'has-children';
var CLASS_BACK_TO_PARENT = 'cta-back-to-parent';
var TIME_SLIDE = 500;
var TIME_EXPANDABLE = 300;
var $body = $('body');
var $header = $(CLASS_HEADER);
var $primaryNav = $(".".concat(CLASS_PRIMARY_NAV));
var $nav = $(".".concat(CLASS_PRIMARY_CONTAINER));
var $micrositeNav = $(".".concat(CLASS_MICROSITE_NAV));
var $micrositeNavLogoLink = $(".".concat(CLASS_MICROSITE_NAV_LOGO_LINK));
var $toolsList = $(".".concat(CLASS_PRIMARY_TOOLS_LIST_CONTAINER));
var $toolsListItem = $(".".concat(CLASS_PRIMARY_TOOLS_LIST));
var $utilityList = $(".".concat(CLASS_PRIMARY_UTILITY_LIST_CONTAINER));
var $trigger = $(".".concat(CLASS_PRIMARY_TOGGLE));
var $triggerOpen = $(".".concat(CLASS_PRIMARY_TRIGGER_OPEN));
var $hasChildren = $(".".concat(CLASS_HAS_CHILDREN));
var $backToParent = $(".".concat(CLASS_BACK_TO_PARENT));
var $childlessLinks = $(".".concat(CLASS_PRIMARY_LINK)).not(".".concat(CLASS_HAS_CHILDREN));
var $expandables = $("\n    .".concat(CLASS_SUBNAV_CONTAINER, ",\n    .").concat(CLASS_SUBNAV_EXPANDABLE, ",\n    .").concat(CLASS_PRIMARY_LINK_EXPANDABLE, ",\n    .").concat(CLASS_SUBNAV_LINK, ".").concat(CLASS_HAS_CHILDREN, "\n  "));
var isMobile;
/**
 * track - analytics for mobile and desktop navs
 *
 * @param   {HTMLElement} el   the trackable element.
 * @returns {void}
 */

function _track(el) {
        analytics.component.link.type = isMobile ? 'mobile nav' : 'desktop nav';
        analytics.component.link.category = el.dataset.category;
        analytics.component.link.description = el.dataset.description;

        _satellite.track('main-navigation');
    }
    /**
     * unHideMobileNavFromSC - un-hides the mobile nav from screen readers
     *
     * @returns {void}
     */


function _unHideMobileNavFromSC() {
        $nav.find(':focusable').removeAttr('tabindex aria-hidden');
    }
    /**
     * hideMobileNavFromSC - hides the mobile nav from screen readers
     *
     * @returns {void}
     */


function _hideMobileNavFromSC() {
        $nav.find(':focusable').attr({
            tabindex: '-1',
            'aria-hidden': 'true'
        });
    }
    /**
     * _unHideMicrositeMobileNavFromSC - un-hides the microsite
     * mobile nav from screen readers
     *
     * @returns {void}
     */


function _unHideMicrositeMobileNavFromSC() {
        $micrositeNavLogoLink.removeAttr('tabindex aria-hidden');
        $micrositeNav.find(':focusable').removeAttr('tabindex aria-hidden');
    }
    /**
     * _hideMicrositeMobileNavFromSC - hides the microsite
     * mobile nav from screen readers
     *
     * @returns {void}
     */


function _hideMicrositeMobileNavFromSC() {
        $micrositeNavLogoLink.attr({
            tabindex: '-1',
            'aria-hidden': 'true'
        });
        $micrositeNav.find(':focusable').attr({
            tabindex: '-1',
            'aria-hidden': 'true'
        });
    }
    /**
     * _toolsAndUtilityMenuHide - Hide Tools list and Utility list sub menus
     *
     * @returns {void}
     */


function _toolsAndUtilityMenuHide() {
        // For mobile menu Tools list and Utility list are always expanded
        $toolsList.attr({
            'aria-hidden': 'true',
            'aria-expanded': 'false'
        });
        $utilityList.attr({
            'aria-hidden': 'true',
            'aria-expanded': 'false'
        });
    }
    /**
     * _toolsAndUtilityMenuShow - Show Tools list and Utility list sub menus
     *
     * @returns {void}
     */


function _toolsAndUtilityMenuShow() {
        // For mobile menu Tools list and Utility list are always expanded
        $toolsList.attr({
            'aria-hidden': 'false'
        }); // On desktop aria-expanded is set by a trigger on mouse over

        $toolsList.removeAttr('aria-expanded');
        $utilityList.attr({
            'aria-hidden': 'false'
        }); // On desktop aria-expanded is not required for utility list

        $utilityList.removeAttr('aria-expanded');
    }
    /**
     * _subNavControlOff - removes the event handler for subnav menus
     *
     * @returns {void}
     */


function _subNavControlOff() {
        $hasChildren.off('click.subNavTrigger');

        _unHideMicrositeMobileNavFromSC(); // The tools menu is shared by both desktop and mobile unlike
        // other menu items. In desktop view, the links in tools
        // should not have tabindex=-1


        $toolsListItem.each(function(i, toolsListItem) {
            $(toolsListItem).removeAttr('tabindex');
        });

        _unHideMobileNavFromSC();

        _toolsAndUtilityMenuHide();
    }
    /**
     * _subNavControlOn - adds the event handler for subnav menus
     *
     * @returns {void}
     */


function _subNavControlOn() {
        // Megamenu adds a sub-pn class when breakpoint > 970px
        // Remove this when the mobile nav is enabled
        $childlessLinks.removeClass(CLASS_SUBNAV_CONTAINER);

        _hideMicrositeMobileNavFromSC();

        _toolsAndUtilityMenuShow();

        _hideMobileNavFromSC(); // Event listener for elements with the class name 'has-children'


        $hasChildren.on('click.subNavTrigger', function(e) {
            // Prevent accordion behaviour on platform variants so accordion trigger acts like an anchor link.
            if ($(e.currentTarget).hasClass(CLASS_PRIMARY_LINK_EXPANDABLE_LOCKED)) {
                return;
            }

            e.preventDefault();
            var $this = $(this);
            var $subNav = $this.next(".".concat(CLASS_SUBNAV_CONTAINER));
            var $parent = $this.parents(".".concat(CLASS_SUBNAV_CONTAINER)); // These menus are positioned inside divs that have to be relative
            // positioned to the accordion to work, so we need to set the top property on the
            // first level subnav to be the distance to the top of the viewport.
            // Each child will inherit the relative position, so we don't want to update those

            if ($parent.length === 1) {
                var rect = $parent[0].getBoundingClientRect();
                var posTop = rect.top + $primaryNav.scrollTop();
                $subNav.css({
                    top: "-".concat(posTop, "px")
                });
            }

            if ($parent.length > 0) {
                // Set the submenu to be the height of the container
                var scrollHeight = $primaryNav.prop('scrollHeight');
                $subNav.css({
                    height: "".concat(scrollHeight, "px")
                });
            } // Add the 'is-transitioning' class


            _addTransitioningState($subNav); // If the nav is currently open, close it


            if ($this.hasClass(CLASS_OPEN)) {
                _toggleOpeningState($this, $subNav); // Timer to remove the 'is-closing' class


                setTimeout(function() {
                    // DTN-1565: Don't set aria-expanded for tools and utility menu in mobile view
                    // since they have no collapse and expand
                    if (!($this.hasClass(CLASS_PRIMARY_TOOLS_LIST) || $this.hasClass(CLASS_PRIMARY_UTILITY_LIST))) {
                        $this.removeClass(CLASS_CLOSING);

                        if (!$this.hasClass(CLASS_SUBNAV_LINK)) {
                            $this.attr('aria-expanded', 'false');
                        }
                    }

                    if (!($subNav.hasClass(CLASS_PRIMARY_TOOLS_LIST) || $subNav.hasClass(CLASS_PRIMARY_UTILITY_LIST))) {
                        $subNav.attr('aria-hidden', 'true').removeClass(CLASS_CLOSING);
                    }
                }, TIME_EXPANDABLE);
            } else {
                // If it's an expandable link, collapse all the rest
                if ($this.hasClass(CLASS_PRIMARY_LINK_EXPANDABLE)) {
                    _collapseExpandables($this);
                } // Add the opening class and set aria attributes


                $this.addClass(CLASS_OPEN);

                if (!$this.hasClass(CLASS_SUBNAV_LINK)) {
                    $this.attr('aria-expanded', 'true');
                }

                $subNav.attr('aria-hidden', 'false').addClass(CLASS_OPEN);
            } // Set the timer to remove the 'is-transitioning' class


            _removeTransitioningStateTimer($subNav);
        });
    }
    /**
     * _collapseExpandables - collapse every expandable sub navigation
     *
     * @param   {HTMLElement} el   the collapsable link element.
     * @returns {void}
     */


function _collapseExpandables(el) {
        // Prevent login expandable from closing other expandables on platform variant
        if ($(el).closest('.header-wrap').attr('data-nav-type') === 'platform') {
            return;
        }

        var $elements = $expandables.not(el); // Note: filter out login nav panel item and its children due to
        // UX treat login as separate entity, not part of the nav panels expandables group

        $elements.filter(function(index, elem) {
            var $elem = $(elem);
            var isLoginItem = $elem.hasClass(CLASS_PRIMARY_LOGIN_ITEM);
            var isChildOfLoginItem = !!$elem.closest(".".concat(CLASS_PRIMARY_LOGIN_ITEM)).length;
            return !isLoginItem && !isChildOfLoginItem;
        });
        $elements.removeClass(CLASS_OPEN);
        $elements.filter(function(index, elem) {
            var $elem = $(elem);
            return !$elem.hasClass(CLASS_SUBNAV_LINK);
        }).attr({
            'aria-expanded': 'false'
        });

        _addTransitioningState($elements);

        _removeTransitioningStateTimer($elements);
    }
    /**
     * _addTransitioningState - adds .is-transitioning class on click
     *
     * @param   {HTMLElement} el   the transitioning element.
     * @returns {void}
     */


function _addTransitioningState(el) {
        el.addClass(CLASS_TRANSITIONING);
    }
    /**
     * _removeTransitioningStateTimer - sets the timer to remove the
     *                                 .is-transitioning class
     *
     * @param   {HTMLElement} el   the transitioning element.
     * @returns {void}
     */


function _removeTransitioningStateTimer(el) {
        setTimeout(function() {
            el.removeClass(CLASS_TRANSITIONING);
        }, TIME_EXPANDABLE);
    }
    /**
     * _removeClosingStateTimer - sets the timer to remove the
     *                           .is-closing class
     *
     * @param   {...HTMLElement} params   elements to remove the class from.
     * @returns {void}
     */


function _removeClosingStateTimer() {
        for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
            params[_key] = arguments[_key];
        }

        params.forEach(function(el) {
            setTimeout(function() {
                el.removeClass(CLASS_CLOSING);
            }, TIME_SLIDE);
        });
    }
    /**
     * _toggleOpeningState - toggle opening/closing states
     *
     * @param   {...HTMLElement} params   elements to toggle
     * @returns {void}
     */


function _toggleOpeningState() {
        for (var _len2 = arguments.length, params = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            params[_key2] = arguments[_key2];
        }

        params.forEach(function(el) {
            el.removeClass(CLASS_OPEN).addClass(CLASS_CLOSING);
        });
    }
    /**
     * _removeSubNavEventHandler - remove the subnavtrigger click event
     *
     * @returns {void}
     */


function _removeSubNavEventHandler() {
        $hasChildren.off('click.subNavTrigger');
    }
    /**
     * _callbackTrigger - event callback for trigger element
     *
     * @param   {Event} e   the event.
     * @returns {void}
     */


function _callbackTrigger(e) {
        e.preventDefault();

        if ($(this).hasClass(CLASS_PRIMARY_TRIGGER_OPEN)) {
            openNavigation();
        } else {
            closeNavigation();
        }
    }
    /**
     * _callbackBackToParent - event callback for trigger element
     *
     * @returns {void}
     */


function _callbackBackToParent() {
        var $subNav = $(this).closest(".".concat(CLASS_SUBNAV_CONTAINER));
        var $anchor = $subNav.siblings(".".concat(CLASS_OPEN));

        _toggleOpeningState($anchor, $subNav);

        _removeClosingStateTimer($anchor, $subNav);
    }
    /**
     * _callbackTrack - event callback for trackable links
     *
     * @returns {void}
     */


function _callbackTrack() {
        _track(this);
    }
    /**
     * _handleResizeChange - event callback for page resizing
     *
     * @returns {void}
     */


function _handleResizeChange() {
        // Multiple orientation changes/resizes cause the event handler to fire multiple times
        _removeSubNavEventHandler();

        if (isMq('lg').matches) {
            _subNavControlOff();

            isMobile = false;
        } else {
            _subNavControlOn();

            isMobile = true;
        }
    }
    /**
     * _toggleMobileNavTabLoop - toggle tabbing behaviour within the mobile nav side overlay
     *
     * @param   {boolean} toEnable  if to enable the accessibility enhancement
     * @returns {void}
     */


function _toggleMobileNavTabLoop(toEnable) {
        var blurEventString = 'blur.mobile-nav-tab-loop';
        var keydownEventString = 'keydown.mobile-nav-tab-loop';
        var $mobileNavCloseTrigger = $nav.find(".".concat(CLASS_PRIMARY_TRIGGER_CLOSE));
        var $firstFocusItemInMobileNav = $($nav.find(".".concat(CLASS_PRIMARY_LINK, ":focusable"))[0]); // clean up residue event handlers regardless

        $mobileNavCloseTrigger.off(blurEventString);
        $firstFocusItemInMobileNav.off(keydownEventString); // enable enahncements

        if (toEnable) {
            // enable forward tab loop so after close trigger, focus go back to first nav item
            $mobileNavCloseTrigger.on(blurEventString, function() {
                $firstFocusItemInMobileNav.focus();
            }); // cancel backward tab on first nav item so cannot exit nav overlay from the top

            $firstFocusItemInMobileNav.on(keydownEventString, function(e) {
                if (e.keyCode === CONSTANTS.KEYBOARD.TAB && e.shiftKey) {
                    e.preventDefault();
                    return false;
                }
            });
        }
    }
    /**
     * _triggerHashAnchorScroll - trigger scroll on hash links
     *
     * @returns {void}
     */


function _triggerHashAnchorScroll(e) {
        var href = $(e.currentTarget).attr('href'); // Only scroll if href starts with a hash

        if (href.substr(0, 1) !== '#') {
            return;
        }

        e.preventDefault(); // Scroll to anchor point

        if (isMobile) {
            $nav.find(".".concat(CLASS_PRIMARY_TRIGGER_CLOSE)).click(); // Give mobile navigation time to close before scrolling

            setTimeout(function() {
                var offset = $(href).data('scroll-offset-y-mobile') || 0;
                scrollToTarget($(href), true, 500, offset);
            }, 300);
        } else {
            var offset = $(href).data('scroll-offset-y') || 0;
            scrollToTarget($(href), true, 500, offset);
        } // Update url


        window.history.pushState(null, '', href);
    }
    /**
     * init - init nav
     *
     * @returns {void}
     */


function navInit() {
        // Mega menu setup
        $primaryNav.megaMenu({
            /* prefix for generated unique id attributes, which are required
                to indicate aria-owns, aria-controls and aria-labelledby */
            uuidPrefix: UUID_PREFIX,

            /* css class used to define the megamenu styling */
            menuClass: CLASS_PRIMARY_LIST,

            /* css class for a top-level navigation item in the megamenu */
            topNavItemClass: CLASS_PRIMARY_ITEM,

            /* css class for a megamenu panel */
            panelClass: CLASS_SUBNAV_CONTAINER,

            /* css class for a group of items within a megamenu panel */
            panelGroupClass: CLASS_SUBNAV_LIST,

            /* css class for the hover state */
            hoverClass: CLASS_HOVER,

            /* css class for the focus state */
            focusClass: CLASS_FOCUS,

            /* css class for the open state */
            openClass: CLASS_OPEN
        });
        isMq('lg').addListener(function() {
            // run function on resize
            _handleResizeChange();
        }); // open/close

        $trigger.on('click', _callbackTrigger); // return to parent

        $backToParent.on('click', _callbackBackToParent); // track click on links in the navigation

        $header.on('click', '[data-navigation][data-category][data-description]', _callbackTrack); // Override scroll behaviour of hash links in primary nav

        $header.on('click', '.pn-link', _triggerHashAnchorScroll); // handle resize on orientation changed

        $(window).on('orientationchangeend', _handleResizeChange); // run function on load

        _handleResizeChange();
    }
    /**
     * openNavigation - opens the mobile navigation
     *
     * @returns {void}
     */

function openNavigation() {
        var currentBodyPosition = "-".concat($body.scrollTop(), "px");
        $nav.addClass(CLASS_ACTIVE);

        _toolsAndUtilityMenuShow();

        _unHideMicrositeMobileNavFromSC();

        _unHideMobileNavFromSC();

        $body.addClass(CLASS_NO_SCROLL).css('top', currentBodyPosition);
        $triggerOpen.attr('aria-expanded', 'true'); // DTN-1562 - enable better accessibility when mobile nav side overlay is active

        _toggleMobileNavTabLoop(true);
    }
    /**
     * closeNavigation - closes the mobile navigation
     *
     * @returns {void}
     */

function closeNavigation() {
        collapseLoginItem();
        var currentBodyPosition = parseInt($body.css('top'), 10) * -1;
        $nav.removeClass(CLASS_ACTIVE);

        _hideMicrositeMobileNavFromSC();

        _hideMobileNavFromSC();

        _toolsAndUtilityMenuHide();

        $triggerOpen.attr('aria-expanded', 'false');
        setTimeout(function() {
            $body.removeClass(CLASS_NO_SCROLL).removeAttr('style').scrollTop(currentBodyPosition);
        }, 200); // DTN-1562 - remove tabbing accessibility enhancement when mobile nav side overlay is inactive

        _toggleMobileNavTabLoop(false);
    }
    /**
     * expandLoginItem - expand login item in mobile navigation
     *
     * @returns {void}
     */

function expandLoginItem() {
        var $loginItemAnchor = $(".".concat(CLASS_PRIMARY_LOGIN_ITEM)).children(".".concat(CLASS_HAS_CHILDREN));
        var $loginItemSubNav = $loginItemAnchor.next(".".concat(CLASS_SUBNAV_CONTAINER)); // ignore if already open

        if ($loginItemAnchor.hasClass(CLASS_OPEN) && $loginItemSubNav.hasClass(CLASS_OPEN)) {
            return false;
        }

        $loginItemSubNav.attr({
            'aria-hidden': 'false',
            'aria-expanded': 'true'
        }).addClass(CLASS_OPEN);
        $loginItemAnchor.attr('aria-expanded', 'true').addClass(CLASS_OPEN).focus();
    }
    /**
     * collapseLoginItem - collapse login item in mobile navigation
     *
     * @returns {void}
     */

function collapseLoginItem() {
    var $loginItemAnchor = $('.pn-login').children(".".concat(CLASS_HAS_CHILDREN));
    var $loginItemSubNav = $loginItemAnchor.next(".".concat(CLASS_SUBNAV_CONTAINER)); // ignore if already closed

    if (!$loginItemAnchor.hasClass(CLASS_OPEN) && !$loginItemSubNav.hasClass(CLASS_OPEN)) {
        return false;
    }

    $loginItemAnchor.attr('aria-expanded', 'false').removeClass(CLASS_OPEN);
    $loginItemSubNav.attr({
        'aria-hidden': 'true',
        'aria-expanded': 'false'
    }).removeClass(CLASS_OPEN);
}; // CONCATENATED MODULE: ./ui.apps/src/main/content/jcr_root/apps/global/components/auspost/header-corporate/clientlib/src/js/import/nav-login.js


// mobile view elements

var $mobileHeader = $('#header');
var $mobileContainer = $mobileHeader.find('.login-options-container--mobile'); // mobile login container in old IA

var $mobileNavPanel = $mobileHeader.find('.pn-container'); // mobile nav panel from left

var $mobileLoginButton = $mobileHeader.find('.btn-login-trigger--mobile'); // login button from mobile header
// desktop view elements

var $topNav = $('.top-nav');
var $topNavLoginItem = $topNav.find('.top-nav-list-item--login');
var $desktopLoginButton = $topNav.find('.btn-login-trigger--desktop');
var loginNamespace = 'global-header-login';
var timeout;
/**
 *
 * Mobile functions
 */

function _openMobileContainer() {
    // for old IA mobile container
    set(loginNamespace, $mobileContainer);
    $mobileLoginButton.attr('aria-expanded', 'true');
    $mobileContainer.addClass('is-open');
    $mobileContainer.attr('aria-hidden', 'false');
}

function _closeMobileContainer() {
    // for old IA mobile container
    unset(loginNamespace, $mobileContainer);
    $mobileLoginButton.attr('aria-expanded', 'false');
    $mobileContainer.removeClass('is-open');
    $mobileContainer.attr('aria-hidden', 'true');
}

function _openMobileNavPanel() {
    // opens mobile nav panel on left and expand login item
    openNavigation();
    expandLoginItem();
}

function _closeMobileNavPanel() {
    // opens mobile nav panel on left
    closeNavigation();
}

function _mobileEvents() {
        $mobileLoginButton.on('click', function() {
            // old IA: popup login container
            if ($mobileContainer.length) {
                if ($mobileContainer.hasClass(CONSTANTS.CLASSES.OPEN)) {
                    _closeMobileContainer();
                } else {
                    _openMobileContainer();
                }

                return;
            } // new left panel IA


            if ($mobileNavPanel.hasClass(CONSTANTS.CLASSES.ACTIVE)) {
                _closeMobileNavPanel();
            } else {
                _openMobileNavPanel();
            }
        });
    }
    /**
     *
     * Desktop functions
     *
     */
    // TODO: update desktop code to suit new IA design, code below still applies to old IA design


function _openDesktopContainer() {
    $topNavLoginItem.addClass('is-expanded');
    $desktopLoginButton.attr('aria-expanded', true);
    set(loginNamespace, $topNavLoginItem);
}

function _closeDesktopContainer() {
    $topNavLoginItem.removeClass('is-expanded');
    $desktopLoginButton.attr('aria-expanded', false);
    unset(loginNamespace, $topNavLoginItem);
}

function _desktopContainerIn() {
    clearInterval(timeout);
}

function _desktopContainerOut() {
    // setTimeout is required to get the current active element
    setTimeout(function() {
        var $focus = $(document.activeElement);
        var isButton = $focus.is('.btn-login-trigger--desktop');
        var isLink = $focus.is('.login-option-link');

        if (!isButton && !isLink) {
            timeout = setTimeout(_closeDesktopContainer, 250);
        }
    }, 0);
}

function _desktopEvents() {
    $desktopLoginButton.on('click', function() {
        if ($topNavLoginItem.hasClass('is-expanded')) {
            _closeDesktopContainer();
        } else {
            _openDesktopContainer();
        }
    });
    $topNavLoginItem.on('mouseenter', function() {
        if (!$topNavLoginItem.hasClass('is-expanded')) {
            _openDesktopContainer();
        }

        _desktopContainerIn();
    });
    $topNavLoginItem.on('focusin', _desktopContainerIn);
    $topNavLoginItem.on('focusout', _desktopContainerOut);
    $topNavLoginItem.on('mouseleave', _desktopContainerOut);
}

function navLoginInit() {
    _mobileEvents();

    _desktopEvents();

    $desktopLoginButton.attr('aria-expanded', false);
}; // CONCATENATED MODULE: ./ui.apps/src/main/content/jcr_root/apps/global/components/auspost/header-corporate/clientlib/src/js/import/stickyNav.js

var stickyNav_$header = $('#header');
var isGlobalHeader = $('.global-header, .global-header-old').length;
var isPolWrapperBody;
var headerOffset;
/**
 * _areAlertsPresent()
 */

function _areAlertsPresent() {
        return !!$('.js-global-notification-dismiss').length;
    }
    /**
     * _setRelative()
     *
     * if alert components are present, add is-relative to $header
     *
     * when alert is dismissed, redefine the headerOffset and check
     * again if some other alert is still present
     *
     * if alert components are not present, kill alert.dismissed event
     * remove is-relative from $header
     *
     * if alert components are not present and is not tier one or post
     * office locator, stickyNav is not required, just kill all eventListenner
     */


function _setRelative() {
        if (_areAlertsPresent()) {
            stickyNav_$header.addClass('is-relative');
            $(window).on('alert.dismissed', function() {
                _defineHeaderOffset();

                _setRelative();
            });
        } else {
            $(window).off('alert.dismissed');
            stickyNav_$header.removeClass('is-relative');

            if (isPolWrapperBody) {
                stop();
            }
        }
    }
    /**
     * _defineHeaderOffset()
     */


function _defineHeaderOffset() {
        headerOffset = stickyNav_$header.offset().top;
    }
    /**
     * _stopScrollEvent()
     */


function _stopScrollEvent() {
        $(window).off('scroll.stickynav');
    }
    /**
     * _startScrollEvent()
     *
     * if alert components are present, redefine the header offset
     * if it's not the case, header offset has to be 0
     *
     * on scroll, add or remove the is-sticky class
     */


function _startScrollEvent() {
        if (_areAlertsPresent()) {
            _defineHeaderOffset();
        } else {
            headerOffset = 0;
        }

        $(window).on('scroll.stickynav', function() {
            if ($(window).scrollTop() > headerOffset) {
                stickyNav_$header.addClass('is-sticky');
            } else {
                stickyNav_$header.removeClass('is-sticky');
            }
        });
    }
    /**
     * _handleResizeChange()
     *
     * start or stop the scroll event depending of the current mq matches
     */


function stickyNav_handleResizeChange() {
        if (isMq('lg').matches) {
            _stopScrollEvent();
        } else {
            _startScrollEvent();
        }
    }
    /**
     * stop()
     *
     * kill all eventListeners and remove global-header modifier classes
     */


function stop() {
        stickyNav_$header.removeClass('is-sticky');
        stickyNav_$header.removeClass('is-relative');

        _stopScrollEvent();

        window.removeEventListener('orientationchange.stickynav', stickyNav_handleResizeChange);
        isMq('lg').removeListener(stickyNav_handleResizeChange);
    }
    /**
     * init()
     *
     * stickyNav is required if
     * - global header is present on the page
     * - the page is a post office locator page OR an alert component is present
     */


function stickyNavInit() {
        isPolWrapperBody = $('.pol-wrapper-body').length;

        if (isGlobalHeader || isGlobalHeader && isPolWrapperBody || _areAlertsPresent()) {
            stickyNav_handleResizeChange();

            window.addEventListener('orientationchange.stickynav', stickyNav_handleResizeChange);
            isMq('lg').addListener(stickyNav_handleResizeChange);

            _setRelative();
        }
    }
    // EXTERNAL MODULE: ./ui.frontend/src/main/global/js/vendors/megamenu.js
var megamenu = __webpack_require__(115);; // CONCATENATED MODULE: ./ui.apps/src/main/content/jcr_root/apps/global/components/auspost/header-corporate/clientlib/src/js/header-corporate.js




$(document).ready(function() {
    navLoginInit();
    navInit();
    stickyNavInit();
}); //# sourceURL=[module]
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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