(function () {
    'use strict';

    function noop() {}

    function assign(target) {
        var arguments$1 = arguments;

        var k,
            source,
            i = 1,
            len = arguments.length;
        for (; i < len; i++) {
            source = arguments$1[i];
            for (k in source) {
                target[k] = source[k];
            }
        }

        return target;
    }

    function appendNode(node, target) {
        target.appendChild(node);
    }

    function insertNode(node, target, anchor) {
        target.insertBefore(node, anchor);
    }

    function detachNode(node) {
        node.parentNode.removeChild(node);
    }

    function destroyEach(iterations) {
        for (var i = 0; i < iterations.length; i += 1) {
            if (iterations[i]) {
                iterations[i].d();
            }
        }
    }

    function createElement(name) {
        return document.createElement(name);
    }

    function createText(data) {
        return document.createTextNode(data);
    }

    function createComment() {
        return document.createComment('');
    }

    function addListener(node, event, handler) {
        node.addEventListener(event, handler, false);
    }

    function removeListener(node, event, handler) {
        node.removeEventListener(event, handler, false);
    }

    function setAttribute(node, attribute, value) {
        node.setAttribute(attribute, value);
    }

    function setStyle(node, key, value) {
        node.style.setProperty(key, value);
    }

    function selectOption(select, value) {
        for (var i = 0; i < select.options.length; i += 1) {
            var option = select.options[i];

            if (option.__value === value) {
                option.selected = true;
                return;
            }
        }
    }

    function selectValue(select) {
        var selectedOption =
            select.querySelector(':checked') || select.options[0];
        return selectedOption && selectedOption.__value;
    }

    function blankObject() {
        return Object.create(null);
    }

    function destroy(detach) {
        this.destroy = noop;
        this.fire('destroy');
        this.set = this.get = noop;

        if (detach !== false) {
            this._fragment.u();
        }
        this._fragment.d();
        this._fragment = this._state = null;
    }

    function differs(a, b) {
        return (
            a !== b || (a && typeof a === 'object') || typeof a === 'function'
        );
    }

    function dispatchObservers(component, group, changed, newState, oldState) {
        for (var key in group) {
            if (!changed[key]) {
                continue;
            }

            var newValue = newState[key];
            var oldValue = oldState[key];

            var callbacks = group[key];
            if (!callbacks) {
                continue;
            }

            for (var i = 0; i < callbacks.length; i += 1) {
                var callback = callbacks[i];
                if (callback.__calling) {
                    continue;
                }

                callback.__calling = true;
                callback.call(component, newValue, oldValue);
                callback.__calling = false;
            }
        }
    }

    function fire(eventName, data) {
        var this$1 = this;

        var handlers =
            eventName in this._handlers && this._handlers[eventName].slice();
        if (!handlers) {
            return;
        }

        for (var i = 0; i < handlers.length; i += 1) {
            handlers[i].call(this$1, data);
        }
    }

    function get(key) {
        return key ? this._state[key] : this._state;
    }

    function init(component, options) {
        component._observers = { pre: blankObject(), post: blankObject() };
        component._handlers = blankObject();
        component._bind = options._bind;

        component.options = options;
        component.root = options.root || component;
        component.store = component.root.store || options.store;
    }

    function observe(key, callback, options) {
        var group =
            options && options.defer
                ? this._observers.post
                : this._observers.pre;

        (group[key] || (group[key] = [])).push(callback);

        if (!options || options.init !== false) {
            callback.__calling = true;
            callback.call(this, this._state[key]);
            callback.__calling = false;
        }

        return {
            cancel: function () {
                var index = group[key].indexOf(callback);
                if (~index) {
                    group[key].splice(index, 1);
                }
            },
        };
    }

    function on(eventName, handler) {
        if (eventName === 'teardown') {
            return this.on('destroy', handler);
        }

        var handlers =
            this._handlers[eventName] || (this._handlers[eventName] = []);
        handlers.push(handler);

        return {
            cancel: function () {
                var index = handlers.indexOf(handler);
                if (~index) {
                    handlers.splice(index, 1);
                }
            },
        };
    }

    function set(newState) {
        this._set(assign({}, newState));
        if (this.root._lock) {
            return;
        }
        this.root._lock = true;
        callAll(this.root._beforecreate);
        callAll(this.root._oncreate);
        callAll(this.root._aftercreate);
        this.root._lock = false;
    }

    function _set(newState) {
        var oldState = this._state,
            changed = {},
            dirty = false;

        for (var key in newState) {
            if (differs(newState[key], oldState[key])) {
                changed[key] = dirty = true;
            }
        }
        if (!dirty) {
            return;
        }

        this._state = assign({}, oldState, newState);
        this._recompute(changed, this._state);
        if (this._bind) {
            this._bind(changed, this._state);
        }

        if (this._fragment) {
            dispatchObservers(
                this,
                this._observers.pre,
                changed,
                this._state,
                oldState
            );
            this._fragment.p(changed, this._state);
            dispatchObservers(
                this,
                this._observers.post,
                changed,
                this._state,
                oldState
            );
        }
    }

    function callAll(fns) {
        while (fns && fns.length) {
            fns.pop()();
        }
    }

    function _mount(target, anchor) {
        this._fragment.m(target, anchor);
    }

    function _unmount() {
        if (this._fragment) {
            this._fragment.u();
        }
    }

    var proto = {
        destroy: destroy,
        get: get,
        fire: fire,
        observe: observe,
        on: on,
        set: set,
        teardown: destroy,
        _recompute: noop,
        _set: _set,
        _mount: _mount,
        _unmount: _unmount,
    };

    /* client/source/app/components/Loader.html generated by Svelte v1.50.0 */
    function data() {
        return {
            class: 'off',
        };
    }

    function oncreate$1() {
        var this$1 = this;

        setTimeout(function () {
            return this$1.set({ class: 'on' });
        }, 0);
    }

    function create_main_fragment$1(state, component) {
        var div, div_class_value;

        return {
            c: function create() {
                div = createElement('div');
                div.textContent = 'loading';
                this.h();
            },

            h: function hydrate() {
                div.className = div_class_value = 'loader ' + state.class;
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
            },

            p: function update(changed, state) {
                if (
                    changed.class &&
                    div_class_value !==
                        (div_class_value = 'loader ' + state.class)
                ) {
                    div.className = div_class_value;
                }
            },

            u: function unmount() {
                detachNode(div);
            },

            d: noop,
        };
    }

    function Loader(options) {
        init(this, options);
        this._state = assign(data(), options.data);

        var _oncreate = oncreate$1.bind(this);

        if (!options.root) {
            this._oncreate = [_oncreate];
        } else {
            this.root._oncreate.push(_oncreate);
        }

        this._fragment = create_main_fragment$1(this._state, this);

        if (options.target) {
            this._fragment.c();
            this._fragment.m(options.target, options.anchor || null);

            callAll(this._oncreate);
        }
    }

    assign(Loader.prototype, proto);

    /**
     * @category Common Helpers
     * @summary Is the given argument an instance of Date?
     *
     * @description
     * Is the given argument an instance of Date?
     *
     * @param {*} argument - the argument to check
     * @returns {Boolean} the given argument is an instance of Date
     *
     * @example
     * // Is 'mayonnaise' a Date?
     * var result = isDate('mayonnaise')
     * //=> false
     */
    function isDate(argument) {
        return argument instanceof Date;
    }

    var is_date = isDate;

    var MILLISECONDS_IN_HOUR = 3600000;
    var MILLISECONDS_IN_MINUTE = 60000;
    var DEFAULT_ADDITIONAL_DIGITS = 2;

    var parseTokenDateTimeDelimeter = /[T ]/;
    var parseTokenPlainTime = /:/;

    // year tokens
    var parseTokenYY = /^(\d{2})$/;
    var parseTokensYYY = [
        /^([+-]\d{2})$/, // 0 additional digits
        /^([+-]\d{3})$/, // 1 additional digit
        /^([+-]\d{4})$/, // 2 additional digits
    ];

    var parseTokenYYYY = /^(\d{4})/;
    var parseTokensYYYYY = [
        /^([+-]\d{4})/, // 0 additional digits
        /^([+-]\d{5})/, // 1 additional digit
        /^([+-]\d{6})/, // 2 additional digits
    ];

    // date tokens
    var parseTokenMM = /^-(\d{2})$/;
    var parseTokenDDD = /^-?(\d{3})$/;
    var parseTokenMMDD = /^-?(\d{2})-?(\d{2})$/;
    var parseTokenWww = /^-?W(\d{2})$/;
    var parseTokenWwwD = /^-?W(\d{2})-?(\d{1})$/;

    // time tokens
    var parseTokenHH = /^(\d{2}([.,]\d*)?)$/;
    var parseTokenHHMM = /^(\d{2}):?(\d{2}([.,]\d*)?)$/;
    var parseTokenHHMMSS = /^(\d{2}):?(\d{2}):?(\d{2}([.,]\d*)?)$/;

    // timezone tokens
    var parseTokenTimezone = /([Z+-].*)$/;
    var parseTokenTimezoneZ = /^(Z)$/;
    var parseTokenTimezoneHH = /^([+-])(\d{2})$/;
    var parseTokenTimezoneHHMM = /^([+-])(\d{2}):?(\d{2})$/;

    /**
     * @category Common Helpers
     * @summary Convert the given argument to an instance of Date.
     *
     * @description
     * Convert the given argument to an instance of Date.
     *
     * If the argument is an instance of Date, the function returns its clone.
     *
     * If the argument is a number, it is treated as a timestamp.
     *
     * If an argument is a string, the function tries to parse it.
     * Function accepts complete ISO 8601 formats as well as partial implementations.
     * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
     *
     * If all above fails, the function passes the given argument to Date constructor.
     *
     * @param {Date|String|Number} argument - the value to convert
     * @param {Object} [options] - the object with options
     * @param {0 | 1 | 2} [options.additionalDigits=2] - the additional number of digits in the extended year format
     * @returns {Date} the parsed date in the local time zone
     *
     * @example
     * // Convert string '2014-02-11T11:30:30' to date:
     * var result = parse('2014-02-11T11:30:30')
     * //=> Tue Feb 11 2014 11:30:30
     *
     * @example
     * // Parse string '+02014101',
     * // if the additional number of digits in the extended year format is 1:
     * var result = parse('+02014101', {additionalDigits: 1})
     * //=> Fri Apr 11 2014 00:00:00
     */
    function parse(argument, dirtyOptions) {
        if (is_date(argument)) {
            // Prevent the date to lose the milliseconds when passed to new Date() in IE10
            return new Date(argument.getTime());
        } else if (typeof argument !== 'string') {
            return new Date(argument);
        }

        var options = dirtyOptions || {};
        var additionalDigits = options.additionalDigits;
        if (additionalDigits == null) {
            additionalDigits = DEFAULT_ADDITIONAL_DIGITS;
        } else {
            additionalDigits = Number(additionalDigits);
        }

        var dateStrings = splitDateString(argument);

        var parseYearResult = parseYear(dateStrings.date, additionalDigits);
        var year = parseYearResult.year;
        var restDateString = parseYearResult.restDateString;

        var date = parseDate(restDateString, year);

        if (date) {
            var timestamp = date.getTime();
            var time = 0;
            var offset;

            if (dateStrings.time) {
                time = parseTime(dateStrings.time);
            }

            if (dateStrings.timezone) {
                offset = parseTimezone(dateStrings.timezone);
            } else {
                // get offset accurate to hour in timezones that change offset
                offset = new Date(timestamp + time).getTimezoneOffset();
                offset = new Date(
                    timestamp + time + offset * MILLISECONDS_IN_MINUTE
                ).getTimezoneOffset();
            }

            return new Date(timestamp + time + offset * MILLISECONDS_IN_MINUTE);
        } else {
            return new Date(argument);
        }
    }

    function splitDateString(dateString) {
        var dateStrings = {};
        var array = dateString.split(parseTokenDateTimeDelimeter);
        var timeString;

        if (parseTokenPlainTime.test(array[0])) {
            dateStrings.date = null;
            timeString = array[0];
        } else {
            dateStrings.date = array[0];
            timeString = array[1];
        }

        if (timeString) {
            var token = parseTokenTimezone.exec(timeString);
            if (token) {
                dateStrings.time = timeString.replace(token[1], '');
                dateStrings.timezone = token[1];
            } else {
                dateStrings.time = timeString;
            }
        }

        return dateStrings;
    }

    function parseYear(dateString, additionalDigits) {
        var parseTokenYYY = parseTokensYYY[additionalDigits];
        var parseTokenYYYYY = parseTokensYYYYY[additionalDigits];

        var token;

        // YYYY or ±YYYYY
        token =
            parseTokenYYYY.exec(dateString) || parseTokenYYYYY.exec(dateString);
        if (token) {
            var yearString = token[1];
            return {
                year: parseInt(yearString, 10),
                restDateString: dateString.slice(yearString.length),
            };
        }

        // YY or ±YYY
        token = parseTokenYY.exec(dateString) || parseTokenYYY.exec(dateString);
        if (token) {
            var centuryString = token[1];
            return {
                year: parseInt(centuryString, 10) * 100,
                restDateString: dateString.slice(centuryString.length),
            };
        }

        // Invalid ISO-formatted year
        return {
            year: null,
        };
    }

    function parseDate(dateString, year) {
        // Invalid ISO-formatted year
        if (year === null) {
            return null;
        }

        var token;
        var date;
        var month;
        var week;

        // YYYY
        if (dateString.length === 0) {
            date = new Date(0);
            date.setUTCFullYear(year);
            return date;
        }

        // YYYY-MM
        token = parseTokenMM.exec(dateString);
        if (token) {
            date = new Date(0);
            month = parseInt(token[1], 10) - 1;
            date.setUTCFullYear(year, month);
            return date;
        }

        // YYYY-DDD or YYYYDDD
        token = parseTokenDDD.exec(dateString);
        if (token) {
            date = new Date(0);
            var dayOfYear = parseInt(token[1], 10);
            date.setUTCFullYear(year, 0, dayOfYear);
            return date;
        }

        // YYYY-MM-DD or YYYYMMDD
        token = parseTokenMMDD.exec(dateString);
        if (token) {
            date = new Date(0);
            month = parseInt(token[1], 10) - 1;
            var day = parseInt(token[2], 10);
            date.setUTCFullYear(year, month, day);
            return date;
        }

        // YYYY-Www or YYYYWww
        token = parseTokenWww.exec(dateString);
        if (token) {
            week = parseInt(token[1], 10) - 1;
            return dayOfISOYear(year, week);
        }

        // YYYY-Www-D or YYYYWwwD
        token = parseTokenWwwD.exec(dateString);
        if (token) {
            week = parseInt(token[1], 10) - 1;
            var dayOfWeek = parseInt(token[2], 10) - 1;
            return dayOfISOYear(year, week, dayOfWeek);
        }

        // Invalid ISO-formatted date
        return null;
    }

    function parseTime(timeString) {
        var token;
        var hours;
        var minutes;

        // hh
        token = parseTokenHH.exec(timeString);
        if (token) {
            hours = parseFloat(token[1].replace(',', '.'));
            return (hours % 24) * MILLISECONDS_IN_HOUR;
        }

        // hh:mm or hhmm
        token = parseTokenHHMM.exec(timeString);
        if (token) {
            hours = parseInt(token[1], 10);
            minutes = parseFloat(token[2].replace(',', '.'));
            return (
                (hours % 24) * MILLISECONDS_IN_HOUR +
                minutes * MILLISECONDS_IN_MINUTE
            );
        }

        // hh:mm:ss or hhmmss
        token = parseTokenHHMMSS.exec(timeString);
        if (token) {
            hours = parseInt(token[1], 10);
            minutes = parseInt(token[2], 10);
            var seconds = parseFloat(token[3].replace(',', '.'));
            return (
                (hours % 24) * MILLISECONDS_IN_HOUR +
                minutes * MILLISECONDS_IN_MINUTE +
                seconds * 1000
            );
        }

        // Invalid ISO-formatted time
        return null;
    }

    function parseTimezone(timezoneString) {
        var token;
        var absoluteOffset;

        // Z
        token = parseTokenTimezoneZ.exec(timezoneString);
        if (token) {
            return 0;
        }

        // ±hh
        token = parseTokenTimezoneHH.exec(timezoneString);
        if (token) {
            absoluteOffset = parseInt(token[2], 10) * 60;
            return token[1] === '+' ? -absoluteOffset : absoluteOffset;
        }

        // ±hh:mm or ±hhmm
        token = parseTokenTimezoneHHMM.exec(timezoneString);
        if (token) {
            absoluteOffset =
                parseInt(token[2], 10) * 60 + parseInt(token[3], 10);
            return token[1] === '+' ? -absoluteOffset : absoluteOffset;
        }

        return 0;
    }

    function dayOfISOYear(isoYear, week, day) {
        week = week || 0;
        day = day || 0;
        var date = new Date(0);
        date.setUTCFullYear(isoYear, 0, 4);
        var fourthOfJanuaryDay = date.getUTCDay() || 7;
        var diff = week * 7 + day + 1 - fourthOfJanuaryDay;
        date.setUTCDate(date.getUTCDate() + diff);
        return date;
    }

    var parse_1 = parse;

    /**
     * @category Year Helpers
     * @summary Return the start of a year for the given date.
     *
     * @description
     * Return the start of a year for the given date.
     * The result will be in the local timezone.
     *
     * @param {Date|String|Number} date - the original date
     * @returns {Date} the start of a year
     *
     * @example
     * // The start of a year for 2 September 2014 11:55:00:
     * var result = startOfYear(new Date(2014, 8, 2, 11, 55, 00))
     * //=> Wed Jan 01 2014 00:00:00
     */
    function startOfYear(dirtyDate) {
        var cleanDate = parse_1(dirtyDate);
        var date = new Date(0);
        date.setFullYear(cleanDate.getFullYear(), 0, 1);
        date.setHours(0, 0, 0, 0);
        return date;
    }

    var start_of_year = startOfYear;

    /**
     * @category Day Helpers
     * @summary Return the start of a day for the given date.
     *
     * @description
     * Return the start of a day for the given date.
     * The result will be in the local timezone.
     *
     * @param {Date|String|Number} date - the original date
     * @returns {Date} the start of a day
     *
     * @example
     * // The start of a day for 2 September 2014 11:55:00:
     * var result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))
     * //=> Tue Sep 02 2014 00:00:00
     */
    function startOfDay(dirtyDate) {
        var date = parse_1(dirtyDate);
        date.setHours(0, 0, 0, 0);
        return date;
    }

    var start_of_day = startOfDay;

    var MILLISECONDS_IN_MINUTE$1 = 60000;
    var MILLISECONDS_IN_DAY = 86400000;

    /**
     * @category Day Helpers
     * @summary Get the number of calendar days between the given dates.
     *
     * @description
     * Get the number of calendar days between the given dates.
     *
     * @param {Date|String|Number} dateLeft - the later date
     * @param {Date|String|Number} dateRight - the earlier date
     * @returns {Number} the number of calendar days
     *
     * @example
     * // How many calendar days are between
     * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
     * var result = differenceInCalendarDays(
     *   new Date(2012, 6, 2, 0, 0),
     *   new Date(2011, 6, 2, 23, 0)
     * )
     * //=> 366
     */
    function differenceInCalendarDays(dirtyDateLeft, dirtyDateRight) {
        var startOfDayLeft = start_of_day(dirtyDateLeft);
        var startOfDayRight = start_of_day(dirtyDateRight);

        var timestampLeft =
            startOfDayLeft.getTime() -
            startOfDayLeft.getTimezoneOffset() * MILLISECONDS_IN_MINUTE$1;
        var timestampRight =
            startOfDayRight.getTime() -
            startOfDayRight.getTimezoneOffset() * MILLISECONDS_IN_MINUTE$1;

        // Round the number of days to the nearest integer
        // because the number of milliseconds in a day is not constant
        // (e.g. it's different in the day of the daylight saving time clock shift)
        return Math.round(
            (timestampLeft - timestampRight) / MILLISECONDS_IN_DAY
        );
    }

    var difference_in_calendar_days = differenceInCalendarDays;

    /**
     * @category Day Helpers
     * @summary Get the day of the year of the given date.
     *
     * @description
     * Get the day of the year of the given date.
     *
     * @param {Date|String|Number} date - the given date
     * @returns {Number} the day of year
     *
     * @example
     * // Which day of the year is 2 July 2014?
     * var result = getDayOfYear(new Date(2014, 6, 2))
     * //=> 183
     */
    function getDayOfYear(dirtyDate) {
        var date = parse_1(dirtyDate);
        var diff = difference_in_calendar_days(date, start_of_year(date));
        var dayOfYear = diff + 1;
        return dayOfYear;
    }

    var get_day_of_year = getDayOfYear;

    /**
     * @category Week Helpers
     * @summary Return the start of a week for the given date.
     *
     * @description
     * Return the start of a week for the given date.
     * The result will be in the local timezone.
     *
     * @param {Date|String|Number} date - the original date
     * @param {Object} [options] - the object with options
     * @param {Number} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
     * @returns {Date} the start of a week
     *
     * @example
     * // The start of a week for 2 September 2014 11:55:00:
     * var result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))
     * //=> Sun Aug 31 2014 00:00:00
     *
     * @example
     * // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:
     * var result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), {weekStartsOn: 1})
     * //=> Mon Sep 01 2014 00:00:00
     */
    function startOfWeek(dirtyDate, dirtyOptions) {
        var weekStartsOn = dirtyOptions
            ? Number(dirtyOptions.weekStartsOn) || 0
            : 0;

        var date = parse_1(dirtyDate);
        var day = date.getDay();
        var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;

        date.setDate(date.getDate() - diff);
        date.setHours(0, 0, 0, 0);
        return date;
    }

    var start_of_week = startOfWeek;

    /**
     * @category ISO Week Helpers
     * @summary Return the start of an ISO week for the given date.
     *
     * @description
     * Return the start of an ISO week for the given date.
     * The result will be in the local timezone.
     *
     * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
     *
     * @param {Date|String|Number} date - the original date
     * @returns {Date} the start of an ISO week
     *
     * @example
     * // The start of an ISO week for 2 September 2014 11:55:00:
     * var result = startOfISOWeek(new Date(2014, 8, 2, 11, 55, 0))
     * //=> Mon Sep 01 2014 00:00:00
     */
    function startOfISOWeek(dirtyDate) {
        return start_of_week(dirtyDate, { weekStartsOn: 1 });
    }

    var start_of_iso_week = startOfISOWeek;

    /**
     * @category ISO Week-Numbering Year Helpers
     * @summary Get the ISO week-numbering year of the given date.
     *
     * @description
     * Get the ISO week-numbering year of the given date,
     * which always starts 3 days before the year's first Thursday.
     *
     * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
     *
     * @param {Date|String|Number} date - the given date
     * @returns {Number} the ISO week-numbering year
     *
     * @example
     * // Which ISO-week numbering year is 2 January 2005?
     * var result = getISOYear(new Date(2005, 0, 2))
     * //=> 2004
     */
    function getISOYear(dirtyDate) {
        var date = parse_1(dirtyDate);
        var year = date.getFullYear();

        var fourthOfJanuaryOfNextYear = new Date(0);
        fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
        fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
        var startOfNextYear = start_of_iso_week(fourthOfJanuaryOfNextYear);

        var fourthOfJanuaryOfThisYear = new Date(0);
        fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
        fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
        var startOfThisYear = start_of_iso_week(fourthOfJanuaryOfThisYear);

        if (date.getTime() >= startOfNextYear.getTime()) {
            return year + 1;
        } else if (date.getTime() >= startOfThisYear.getTime()) {
            return year;
        } else {
            return year - 1;
        }
    }

    var get_iso_year = getISOYear;

    /**
     * @category ISO Week-Numbering Year Helpers
     * @summary Return the start of an ISO week-numbering year for the given date.
     *
     * @description
     * Return the start of an ISO week-numbering year,
     * which always starts 3 days before the year's first Thursday.
     * The result will be in the local timezone.
     *
     * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
     *
     * @param {Date|String|Number} date - the original date
     * @returns {Date} the start of an ISO year
     *
     * @example
     * // The start of an ISO week-numbering year for 2 July 2005:
     * var result = startOfISOYear(new Date(2005, 6, 2))
     * //=> Mon Jan 03 2005 00:00:00
     */
    function startOfISOYear(dirtyDate) {
        var year = get_iso_year(dirtyDate);
        var fourthOfJanuary = new Date(0);
        fourthOfJanuary.setFullYear(year, 0, 4);
        fourthOfJanuary.setHours(0, 0, 0, 0);
        var date = start_of_iso_week(fourthOfJanuary);
        return date;
    }

    var start_of_iso_year = startOfISOYear;

    var MILLISECONDS_IN_WEEK = 604800000;

    /**
     * @category ISO Week Helpers
     * @summary Get the ISO week of the given date.
     *
     * @description
     * Get the ISO week of the given date.
     *
     * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
     *
     * @param {Date|String|Number} date - the given date
     * @returns {Number} the ISO week
     *
     * @example
     * // Which week of the ISO-week numbering year is 2 January 2005?
     * var result = getISOWeek(new Date(2005, 0, 2))
     * //=> 53
     */
    function getISOWeek(dirtyDate) {
        var date = parse_1(dirtyDate);
        var diff =
            start_of_iso_week(date).getTime() -
            start_of_iso_year(date).getTime();

        // Round the number of days to the nearest integer
        // because the number of milliseconds in a week is not constant
        // (e.g. it's different in the week of the daylight saving time clock shift)
        return Math.round(diff / MILLISECONDS_IN_WEEK) + 1;
    }

    var get_iso_week = getISOWeek;

    /**
     * @category Common Helpers
     * @summary Is the given date valid?
     *
     * @description
     * Returns false if argument is Invalid Date and true otherwise.
     * Invalid Date is a Date, whose time value is NaN.
     *
     * Time value of Date: http://es5.github.io/#x15.9.1.1
     *
     * @param {Date} date - the date to check
     * @returns {Boolean} the date is valid
     * @throws {TypeError} argument must be an instance of Date
     *
     * @example
     * // For the valid date:
     * var result = isValid(new Date(2014, 1, 31))
     * //=> true
     *
     * @example
     * // For the invalid date:
     * var result = isValid(new Date(''))
     * //=> false
     */
    function isValid(dirtyDate) {
        if (is_date(dirtyDate)) {
            return !isNaN(dirtyDate);
        } else {
            throw new TypeError(
                toString.call(dirtyDate) + ' is not an instance of Date'
            );
        }
    }

    var is_valid = isValid;

    function buildDistanceInWordsLocale() {
        var distanceInWordsLocale = {
            lessThanXSeconds: {
                one: 'less than a second',
                other: 'less than {{count}} seconds',
            },

            xSeconds: {
                one: '1 second',
                other: '{{count}} seconds',
            },

            halfAMinute: 'half a minute',

            lessThanXMinutes: {
                one: 'less than a minute',
                other: 'less than {{count}} minutes',
            },

            xMinutes: {
                one: '1 minute',
                other: '{{count}} minutes',
            },

            aboutXHours: {
                one: 'about 1 hour',
                other: 'about {{count}} hours',
            },

            xHours: {
                one: '1 hour',
                other: '{{count}} hours',
            },

            xDays: {
                one: '1 day',
                other: '{{count}} days',
            },

            aboutXMonths: {
                one: 'about 1 month',
                other: 'about {{count}} months',
            },

            xMonths: {
                one: '1 month',
                other: '{{count}} months',
            },

            aboutXYears: {
                one: 'about 1 year',
                other: 'about {{count}} years',
            },

            xYears: {
                one: '1 year',
                other: '{{count}} years',
            },

            overXYears: {
                one: 'over 1 year',
                other: 'over {{count}} years',
            },

            almostXYears: {
                one: 'almost 1 year',
                other: 'almost {{count}} years',
            },
        };

        function localize(token, count, options) {
            options = options || {};

            var result;
            if (typeof distanceInWordsLocale[token] === 'string') {
                result = distanceInWordsLocale[token];
            } else if (count === 1) {
                result = distanceInWordsLocale[token].one;
            } else {
                result = distanceInWordsLocale[token].other.replace(
                    '{{count}}',
                    count
                );
            }

            if (options.addSuffix) {
                if (options.comparison > 0) {
                    return 'in ' + result;
                } else {
                    return result + ' ago';
                }
            }

            return result;
        }

        return {
            localize: localize,
        };
    }

    var build_distance_in_words_locale = buildDistanceInWordsLocale;

    var commonFormatterKeys = [
        'M',
        'MM',
        'Q',
        'D',
        'DD',
        'DDD',
        'DDDD',
        'd',
        'E',
        'W',
        'WW',
        'YY',
        'YYYY',
        'GG',
        'GGGG',
        'H',
        'HH',
        'h',
        'hh',
        'm',
        'mm',
        's',
        'ss',
        'S',
        'SS',
        'SSS',
        'Z',
        'ZZ',
        'X',
        'x',
    ];

    function buildFormattingTokensRegExp(formatters) {
        var formatterKeys = [];
        for (var key in formatters) {
            if (formatters.hasOwnProperty(key)) {
                formatterKeys.push(key);
            }
        }

        var formattingTokens = commonFormatterKeys
            .concat(formatterKeys)
            .sort()
            .reverse();
        var formattingTokensRegExp = new RegExp(
            '(\\[[^\\[]*\\])|(\\\\)?' +
                '(' +
                formattingTokens.join('|') +
                '|.)',
            'g'
        );

        return formattingTokensRegExp;
    }

    var build_formatting_tokens_reg_exp = buildFormattingTokensRegExp;

    function buildFormatLocale() {
        // Note: in English, the names of days of the week and months are capitalized.
        // If you are making a new locale based on this one, check if the same is true for the language you're working on.
        // Generally, formatted dates should look like they are in the middle of a sentence,
        // e.g. in Spanish language the weekdays and months should be in the lowercase.
        var months3char = [
            'Jan',
            'Feb',
            'Mar',
            'Apr',
            'May',
            'Jun',
            'Jul',
            'Aug',
            'Sep',
            'Oct',
            'Nov',
            'Dec',
        ];
        var monthsFull = [
            'January',
            'February',
            'March',
            'April',
            'May',
            'June',
            'July',
            'August',
            'September',
            'October',
            'November',
            'December',
        ];
        var weekdays2char = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'];
        var weekdays3char = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
        var weekdaysFull = [
            'Sunday',
            'Monday',
            'Tuesday',
            'Wednesday',
            'Thursday',
            'Friday',
            'Saturday',
        ];
        var meridiemUppercase = ['AM', 'PM'];
        var meridiemLowercase = ['am', 'pm'];
        var meridiemFull = ['a.m.', 'p.m.'];

        var formatters = {
            // Month: Jan, Feb, ..., Dec
            MMM: function (date) {
                return months3char[date.getMonth()];
            },

            // Month: January, February, ..., December
            MMMM: function (date) {
                return monthsFull[date.getMonth()];
            },

            // Day of week: Su, Mo, ..., Sa
            dd: function (date) {
                return weekdays2char[date.getDay()];
            },

            // Day of week: Sun, Mon, ..., Sat
            ddd: function (date) {
                return weekdays3char[date.getDay()];
            },

            // Day of week: Sunday, Monday, ..., Saturday
            dddd: function (date) {
                return weekdaysFull[date.getDay()];
            },

            // AM, PM
            A: function (date) {
                return date.getHours() / 12 >= 1
                    ? meridiemUppercase[1]
                    : meridiemUppercase[0];
            },

            // am, pm
            a: function (date) {
                return date.getHours() / 12 >= 1
                    ? meridiemLowercase[1]
                    : meridiemLowercase[0];
            },

            // a.m., p.m.
            aa: function (date) {
                return date.getHours() / 12 >= 1
                    ? meridiemFull[1]
                    : meridiemFull[0];
            },
        };

        // Generate ordinal version of formatters: M -> Mo, D -> Do, etc.
        var ordinalFormatters = ['M', 'D', 'DDD', 'd', 'Q', 'W'];
        ordinalFormatters.forEach(function (formatterToken) {
            formatters[formatterToken + 'o'] = function (date, formatters) {
                return ordinal(formatters[formatterToken](date));
            };
        });

        return {
            formatters: formatters,
            formattingTokensRegExp: build_formatting_tokens_reg_exp(formatters),
        };
    }

    function ordinal(number) {
        var rem100 = number % 100;
        if (rem100 > 20 || rem100 < 10) {
            switch (rem100 % 10) {
                case 1:
                    return number + 'st';
                case 2:
                    return number + 'nd';
                case 3:
                    return number + 'rd';
            }
        }
        return number + 'th';
    }

    var build_format_locale = buildFormatLocale;

    /**
     * @category Locales
     * @summary English locale.
     */
    var en = {
        distanceInWords: build_distance_in_words_locale(),
        format: build_format_locale(),
    };

    /**
     * @category Common Helpers
     * @summary Format the date.
     *
     * @description
     * Return the formatted date string in the given format.
     *
     * Accepted tokens:
     * | Unit                    | Token | Result examples                  |
     * |-------------------------|-------|----------------------------------|
     * | Month                   | M     | 1, 2, ..., 12                    |
     * |                         | Mo    | 1st, 2nd, ..., 12th              |
     * |                         | MM    | 01, 02, ..., 12                  |
     * |                         | MMM   | Jan, Feb, ..., Dec               |
     * |                         | MMMM  | January, February, ..., December |
     * | Quarter                 | Q     | 1, 2, 3, 4                       |
     * |                         | Qo    | 1st, 2nd, 3rd, 4th               |
     * | Day of month            | D     | 1, 2, ..., 31                    |
     * |                         | Do    | 1st, 2nd, ..., 31st              |
     * |                         | DD    | 01, 02, ..., 31                  |
     * | Day of year             | DDD   | 1, 2, ..., 366                   |
     * |                         | DDDo  | 1st, 2nd, ..., 366th             |
     * |                         | DDDD  | 001, 002, ..., 366               |
     * | Day of week             | d     | 0, 1, ..., 6                     |
     * |                         | do    | 0th, 1st, ..., 6th               |
     * |                         | dd    | Su, Mo, ..., Sa                  |
     * |                         | ddd   | Sun, Mon, ..., Sat               |
     * |                         | dddd  | Sunday, Monday, ..., Saturday    |
     * | Day of ISO week         | E     | 1, 2, ..., 7                     |
     * | ISO week                | W     | 1, 2, ..., 53                    |
     * |                         | Wo    | 1st, 2nd, ..., 53rd              |
     * |                         | WW    | 01, 02, ..., 53                  |
     * | Year                    | YY    | 00, 01, ..., 99                  |
     * |                         | YYYY  | 1900, 1901, ..., 2099            |
     * | ISO week-numbering year | GG    | 00, 01, ..., 99                  |
     * |                         | GGGG  | 1900, 1901, ..., 2099            |
     * | AM/PM                   | A     | AM, PM                           |
     * |                         | a     | am, pm                           |
     * |                         | aa    | a.m., p.m.                       |
     * | Hour                    | H     | 0, 1, ... 23                     |
     * |                         | HH    | 00, 01, ... 23                   |
     * |                         | h     | 1, 2, ..., 12                    |
     * |                         | hh    | 01, 02, ..., 12                  |
     * | Minute                  | m     | 0, 1, ..., 59                    |
     * |                         | mm    | 00, 01, ..., 59                  |
     * | Second                  | s     | 0, 1, ..., 59                    |
     * |                         | ss    | 00, 01, ..., 59                  |
     * | 1/10 of second          | S     | 0, 1, ..., 9                     |
     * | 1/100 of second         | SS    | 00, 01, ..., 99                  |
     * | Millisecond             | SSS   | 000, 001, ..., 999               |
     * | Timezone                | Z     | -01:00, +00:00, ... +12:00       |
     * |                         | ZZ    | -0100, +0000, ..., +1200         |
     * | Seconds timestamp       | X     | 512969520                        |
     * | Milliseconds timestamp  | x     | 512969520900                     |
     *
     * The characters wrapped in square brackets are escaped.
     *
     * The result may vary by locale.
     *
     * @param {Date|String|Number} date - the original date
     * @param {String} [format='YYYY-MM-DDTHH:mm:ss.SSSZ'] - the string of tokens
     * @param {Object} [options] - the object with options
     * @param {Object} [options.locale=enLocale] - the locale object
     * @returns {String} the formatted date string
     *
     * @example
     * // Represent 11 February 2014 in middle-endian format:
     * var result = format(
     *   new Date(2014, 1, 11),
     *   'MM/DD/YYYY'
     * )
     * //=> '02/11/2014'
     *
     * @example
     * // Represent 2 July 2014 in Esperanto:
     * var eoLocale = require('date-fns/locale/eo')
     * var result = format(
     *   new Date(2014, 6, 2),
     *   'Do [de] MMMM YYYY',
     *   {locale: eoLocale}
     * )
     * //=> '2-a de julio 2014'
     */
    function format(dirtyDate, dirtyFormatStr, dirtyOptions) {
        var formatStr = dirtyFormatStr
            ? String(dirtyFormatStr)
            : 'YYYY-MM-DDTHH:mm:ss.SSSZ';
        var options = dirtyOptions || {};

        var locale = options.locale;
        var localeFormatters = en.format.formatters;
        var formattingTokensRegExp = en.format.formattingTokensRegExp;
        if (locale && locale.format && locale.format.formatters) {
            localeFormatters = locale.format.formatters;

            if (locale.format.formattingTokensRegExp) {
                formattingTokensRegExp = locale.format.formattingTokensRegExp;
            }
        }

        var date = parse_1(dirtyDate);

        if (!is_valid(date)) {
            return 'Invalid Date';
        }

        var formatFn = buildFormatFn(
            formatStr,
            localeFormatters,
            formattingTokensRegExp
        );

        return formatFn(date);
    }

    var formatters = {
        // Month: 1, 2, ..., 12
        M: function (date) {
            return date.getMonth() + 1;
        },

        // Month: 01, 02, ..., 12
        MM: function (date) {
            return addLeadingZeros(date.getMonth() + 1, 2);
        },

        // Quarter: 1, 2, 3, 4
        Q: function (date) {
            return Math.ceil((date.getMonth() + 1) / 3);
        },

        // Day of month: 1, 2, ..., 31
        D: function (date) {
            return date.getDate();
        },

        // Day of month: 01, 02, ..., 31
        DD: function (date) {
            return addLeadingZeros(date.getDate(), 2);
        },

        // Day of year: 1, 2, ..., 366
        DDD: function (date) {
            return get_day_of_year(date);
        },

        // Day of year: 001, 002, ..., 366
        DDDD: function (date) {
            return addLeadingZeros(get_day_of_year(date), 3);
        },

        // Day of week: 0, 1, ..., 6
        d: function (date) {
            return date.getDay();
        },

        // Day of ISO week: 1, 2, ..., 7
        E: function (date) {
            return date.getDay() || 7;
        },

        // ISO week: 1, 2, ..., 53
        W: function (date) {
            return get_iso_week(date);
        },

        // ISO week: 01, 02, ..., 53
        WW: function (date) {
            return addLeadingZeros(get_iso_week(date), 2);
        },

        // Year: 00, 01, ..., 99
        YY: function (date) {
            return addLeadingZeros(date.getFullYear(), 4).substr(2);
        },

        // Year: 1900, 1901, ..., 2099
        YYYY: function (date) {
            return addLeadingZeros(date.getFullYear(), 4);
        },

        // ISO week-numbering year: 00, 01, ..., 99
        GG: function (date) {
            return String(get_iso_year(date)).substr(2);
        },

        // ISO week-numbering year: 1900, 1901, ..., 2099
        GGGG: function (date) {
            return get_iso_year(date);
        },

        // Hour: 0, 1, ... 23
        H: function (date) {
            return date.getHours();
        },

        // Hour: 00, 01, ..., 23
        HH: function (date) {
            return addLeadingZeros(date.getHours(), 2);
        },

        // Hour: 1, 2, ..., 12
        h: function (date) {
            var hours = date.getHours();
            if (hours === 0) {
                return 12;
            } else if (hours > 12) {
                return hours % 12;
            } else {
                return hours;
            }
        },

        // Hour: 01, 02, ..., 12
        hh: function (date) {
            return addLeadingZeros(formatters['h'](date), 2);
        },

        // Minute: 0, 1, ..., 59
        m: function (date) {
            return date.getMinutes();
        },

        // Minute: 00, 01, ..., 59
        mm: function (date) {
            return addLeadingZeros(date.getMinutes(), 2);
        },

        // Second: 0, 1, ..., 59
        s: function (date) {
            return date.getSeconds();
        },

        // Second: 00, 01, ..., 59
        ss: function (date) {
            return addLeadingZeros(date.getSeconds(), 2);
        },

        // 1/10 of second: 0, 1, ..., 9
        S: function (date) {
            return Math.floor(date.getMilliseconds() / 100);
        },

        // 1/100 of second: 00, 01, ..., 99
        SS: function (date) {
            return addLeadingZeros(Math.floor(date.getMilliseconds() / 10), 2);
        },

        // Millisecond: 000, 001, ..., 999
        SSS: function (date) {
            return addLeadingZeros(date.getMilliseconds(), 3);
        },

        // Timezone: -01:00, +00:00, ... +12:00
        Z: function (date) {
            return formatTimezone(date.getTimezoneOffset(), ':');
        },

        // Timezone: -0100, +0000, ... +1200
        ZZ: function (date) {
            return formatTimezone(date.getTimezoneOffset());
        },

        // Seconds timestamp: 512969520
        X: function (date) {
            return Math.floor(date.getTime() / 1000);
        },

        // Milliseconds timestamp: 512969520900
        x: function (date) {
            return date.getTime();
        },
    };

    function buildFormatFn(
        formatStr,
        localeFormatters,
        formattingTokensRegExp
    ) {
        var array = formatStr.match(formattingTokensRegExp);
        var length = array.length;

        var i;
        var formatter;
        for (i = 0; i < length; i++) {
            formatter = localeFormatters[array[i]] || formatters[array[i]];
            if (formatter) {
                array[i] = formatter;
            } else {
                array[i] = removeFormattingTokens(array[i]);
            }
        }

        return function (date) {
            var output = '';
            for (var i = 0; i < length; i++) {
                if (array[i] instanceof Function) {
                    output += array[i](date, formatters);
                } else {
                    output += array[i];
                }
            }
            return output;
        };
    }

    function removeFormattingTokens(input) {
        if (input.match(/\[[\s\S]/)) {
            return input.replace(/^\[|]$/g, '');
        }
        return input.replace(/\\/g, '');
    }

    function formatTimezone(offset, delimeter) {
        delimeter = delimeter || '';
        var sign = offset > 0 ? '-' : '+';
        var absOffset = Math.abs(offset);
        var hours = Math.floor(absOffset / 60);
        var minutes = absOffset % 60;
        return (
            sign +
            addLeadingZeros(hours, 2) +
            delimeter +
            addLeadingZeros(minutes, 2)
        );
    }

    function addLeadingZeros(number, targetLength) {
        var output = Math.abs(number).toString();
        while (output.length < targetLength) {
            output = '0' + output;
        }
        return output;
    }

    var format_1 = format;

    /**
     * @category Millisecond Helpers
     * @summary Get the number of milliseconds between the given dates.
     *
     * @description
     * Get the number of milliseconds between the given dates.
     *
     * @param {Date|String|Number} dateLeft - the later date
     * @param {Date|String|Number} dateRight - the earlier date
     * @returns {Number} the number of milliseconds
     *
     * @example
     * // How many milliseconds are between
     * // 2 July 2014 12:30:20.600 and 2 July 2014 12:30:21.700?
     * var result = differenceInMilliseconds(
     *   new Date(2014, 6, 2, 12, 30, 21, 700),
     *   new Date(2014, 6, 2, 12, 30, 20, 600)
     * )
     * //=> 1100
     */
    function differenceInMilliseconds(dirtyDateLeft, dirtyDateRight) {
        var dateLeft = parse_1(dirtyDateLeft);
        var dateRight = parse_1(dirtyDateRight);
        return dateLeft.getTime() - dateRight.getTime();
    }

    var difference_in_milliseconds = differenceInMilliseconds;

    var MILLISECONDS_IN_HOUR$1 = 3600000;

    /**
     * @category Hour Helpers
     * @summary Get the number of hours between the given dates.
     *
     * @description
     * Get the number of hours between the given dates.
     *
     * @param {Date|String|Number} dateLeft - the later date
     * @param {Date|String|Number} dateRight - the earlier date
     * @returns {Number} the number of hours
     *
     * @example
     * // How many hours are between 2 July 2014 06:50:00 and 2 July 2014 19:00:00?
     * var result = differenceInHours(
     *   new Date(2014, 6, 2, 19, 0),
     *   new Date(2014, 6, 2, 6, 50)
     * )
     * //=> 12
     */
    function differenceInHours(dirtyDateLeft, dirtyDateRight) {
        var diff =
            difference_in_milliseconds(dirtyDateLeft, dirtyDateRight) /
            MILLISECONDS_IN_HOUR$1;
        return diff > 0 ? Math.floor(diff) : Math.ceil(diff);
    }

    var difference_in_hours = differenceInHours;

    var MILLISECONDS_IN_MINUTE$2 = 60000;

    /**
     * @category Minute Helpers
     * @summary Get the number of minutes between the given dates.
     *
     * @description
     * Get the number of minutes between the given dates.
     *
     * @param {Date|String|Number} dateLeft - the later date
     * @param {Date|String|Number} dateRight - the earlier date
     * @returns {Number} the number of minutes
     *
     * @example
     * // How many minutes are between 2 July 2014 12:07:59 and 2 July 2014 12:20:00?
     * var result = differenceInMinutes(
     *   new Date(2014, 6, 2, 12, 20, 0),
     *   new Date(2014, 6, 2, 12, 7, 59)
     * )
     * //=> 12
     */
    function differenceInMinutes(dirtyDateLeft, dirtyDateRight) {
        var diff =
            difference_in_milliseconds(dirtyDateLeft, dirtyDateRight) /
            MILLISECONDS_IN_MINUTE$2;
        return diff > 0 ? Math.floor(diff) : Math.ceil(diff);
    }

    var difference_in_minutes = differenceInMinutes;

    /**
     * @category Second Helpers
     * @summary Get the number of seconds between the given dates.
     *
     * @description
     * Get the number of seconds between the given dates.
     *
     * @param {Date|String|Number} dateLeft - the later date
     * @param {Date|String|Number} dateRight - the earlier date
     * @returns {Number} the number of seconds
     *
     * @example
     * // How many seconds are between
     * // 2 July 2014 12:30:07.999 and 2 July 2014 12:30:20.000?
     * var result = differenceInSeconds(
     *   new Date(2014, 6, 2, 12, 30, 20, 0),
     *   new Date(2014, 6, 2, 12, 30, 7, 999)
     * )
     * //=> 12
     */
    function differenceInSeconds(dirtyDateLeft, dirtyDateRight) {
        var diff =
            difference_in_milliseconds(dirtyDateLeft, dirtyDateRight) / 1000;
        return diff > 0 ? Math.floor(diff) : Math.ceil(diff);
    }

    var difference_in_seconds = differenceInSeconds;

    /* client/source/app/components/TwitterBlock.html generated by Svelte v1.50.0 */
    /* eslint-disable */
    /**
     * NOTE: the following was hoisted from Tweetie.js
     * https://github.com/sonnyt/tweetie
     */
    var linking = function (tweet) {
        var twit = tweet
            .replace(
                /(https?:\/\/([-\w\.]+)+(:\d+)?(\/([\w\/_\.]*(\?\S+)?)?)?)/gi,
                '<a href="$1" target="_blank" title="Visit this link">$1</a>'
            )
            .replace(
                /#([a-zA-Z0-9_]+)/g,
                '<a href="https://twitter.com/search?q=%23$1&amp;src=hash" target="_blank" title="Search for #$1">#$1</a>'
            )
            .replace(
                /@([a-zA-Z0-9_]+)/g,
                '<a href="https://twitter.com/$1" target="_blank" title="$1 on Twitter">@$1</a>'
            );
        return twit;
    };
    // END OF HOIST!
    /* eslint-enable */

    function loaded(stories) {
        return !!stories;
    }

    function oncreate() {
        var this$1 = this;

        // one time fetch
        fetch(this.get('url'))
            .then(function (response) {
                return response.json();
            })
            .then(function (json) {
                var stories = _.map(
                    _.filter(json, function (story) {
                        /* eslint-disable camelcase */
                        // return !story.retweeted && !story.in_reply_to_screen_name
                        return !story.in_reply_to_screen_name;
                        /* eslint-enable */
                    }),
                    function (story) {
                        var then = parse_1(story.created_at);
                        var now = new Date();
                        var timestamp = '';
                        var diff = difference_in_hours(now, then);
                        if (diff < 24) {
                            if (diff < 1) {
                                diff = difference_in_minutes(now, then);
                                if (diff < 1) {
                                    diff = difference_in_seconds(now, then);
                                    timestamp = diff + 's';
                                } else {
                                    timestamp = diff + 'm';
                                }
                            } else {
                                timestamp = diff + 'h';
                            }
                        } else {
                            timestamp = format_1(then, 'MMM d');
                        }

                        return {
                            timestamp: timestamp,
                            href:
                                'https://twitter.com/' +
                                story.user.screen_name +
                                '/status/' +
                                story.id_str,
                            html: story.retweeted
                                ? linking(
                                      'RT @' +
                                          story.user.screen_name +
                                          ': ' +
                                          story.retweeted_status.text
                                  )
                                : linking(story.text),
                        };
                    }
                );
                this$1.set({
                    username: linking('@' + json[0].user.screen_name),
                    stories: stories.slice(0, 3),
                });
            });
        // TODO: handle errors gracefully?
        // .catch(ex => console.log('parsing failed', ex))

        // unfortunately, this is necessary to make sure
        // any page setup elsewhere is recalibrated
        this.observe('loaded', function () {
            setTimeout(function () {
                var resizeEvent = window.document.createEvent('UIEvents');
                resizeEvent.initUIEvent('resize', true, false, window, 0);
                window.dispatchEvent(resizeEvent);
            }, 0);
        });
    }

    function create_main_fragment(state, component) {
        var if_block_anchor;

        var current_block_type = select_block_type(state);
        var if_block = current_block_type(state, component);

        return {
            c: function create() {
                if_block.c();
                if_block_anchor = createComment();
            },

            m: function mount(target, anchor) {
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type(state)) &&
                    if_block
                ) {
                    if_block.p(changed, state);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                if_block.d();
            },
        };
    }

    // (99:40) {{#each stories as story}}
    function create_each_block(state, stories, story, story_index, component) {
        var div,
            div_1,
            raw_value = story.html,
            a,
            text_value = story.timestamp,
            text,
            a_href_value;

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');
                a = createElement('a');
                text = createText(text_value);
                this.h();
            },

            h: function hydrate() {
                div_1.className = 'tweet';
                a.className = 'timestamp';
                a.href = a_href_value = story.href;
                a.target = '_blank';
                div.className = 'item cell small-12 medium-4';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                div_1.innerHTML = raw_value;
                appendNode(a, div);
                appendNode(text, a);
            },

            p: function update(changed, state, stories, story, story_index) {
                if (changed.stories && raw_value !== (raw_value = story.html)) {
                    div_1.innerHTML = raw_value;
                }

                if (
                    changed.stories &&
                    text_value !== (text_value = story.timestamp)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.stories &&
                    a_href_value !== (a_href_value = story.href)
                ) {
                    a.href = a_href_value;
                }
            },

            u: function unmount() {
                div_1.innerHTML = '';

                detachNode(div);
            },

            d: noop,
        };
    }

    // (97:9) {{#if loaded}}
    function create_if_block(state, component) {
        var h2, text, div;

        var stories = state.stories;

        var each_blocks = [];

        for (var i = 0; i < stories.length; i += 1) {
            each_blocks[i] = create_each_block(
                state,
                stories,
                stories[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                h2 = createElement('h2');
                text = createText('\r\n');
                div = createElement('div');

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }
                this.h();
            },

            h: function hydrate() {
                div.className = 'items grid-x grid-margin-x';
            },

            m: function mount(target, anchor) {
                insertNode(h2, target, anchor);
                h2.innerHTML = state.username;
                insertNode(text, target, anchor);
                insertNode(div, target, anchor);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(div, null);
                }
            },

            p: function update(changed, state) {
                if (changed.username) {
                    h2.innerHTML = state.username;
                }

                var stories = state.stories;

                if (changed.stories) {
                    for (var i = 0; i < stories.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                stories,
                                stories[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block(
                                state,
                                stories,
                                stories[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(div, null);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = stories.length;
                }
            },

            u: function unmount() {
                h2.innerHTML = '';

                detachNode(h2);
                detachNode(text);
                detachNode(div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);
            },
        };
    }

    // (103:6) {{else}}
    function create_if_block_1(state, component) {
        var loader = new Loader({
            root: component.root,
        });

        return {
            c: function create() {
                loader._fragment.c();
            },

            m: function mount(target, anchor) {
                loader._mount(target, anchor);
            },

            p: noop,

            u: function unmount() {
                loader._unmount();
            },

            d: function destroy$$1() {
                loader.destroy(false);
            },
        };
    }

    function select_block_type(state) {
        if (state.loaded) {
            return create_if_block;
        }
        return create_if_block_1;
    }

    function TwitterBlock(options) {
        init(this, options);
        this._state = assign({}, options.data);
        this._recompute({ stories: 1 }, this._state);

        var _oncreate = oncreate.bind(this);

        if (!options.root) {
            this._oncreate = [_oncreate];
            this._beforecreate = [];
            this._aftercreate = [];
        } else {
            this.root._oncreate.push(_oncreate);
        }

        this._fragment = create_main_fragment(this._state, this);

        if (options.target) {
            this._fragment.c();
            this._fragment.m(options.target, options.anchor || null);

            this._lock = true;
            callAll(this._beforecreate);
            callAll(this._oncreate);
            callAll(this._aftercreate);
            this._lock = false;
        }
    }

    assign(TwitterBlock.prototype, proto);

    TwitterBlock.prototype._recompute = function _recompute(changed, state) {
        if (changed.stories) {
            if (differs(state.loaded, (state.loaded = loaded(state.stories)))) {
                changed.loaded = true;
            }
        }
    };

    function isDate$2(obj) {
        return Object.prototype.toString.call(obj) === '[object Date]';
    }

    var scheduler = {
        components: [],
        running: false,
        add: function (component) {
            if (~scheduler.components.indexOf(component)) {
                return;
            }
            scheduler.components.push(component);
            if (!scheduler.running) {
                scheduler.running = true;
                requestAnimationFrame(scheduler.next);
            }
        },
        next: function () {
            var now = window.performance.now();
            var hasComponents = false;
            var i = scheduler.components.length;
            while (i--) {
                var component = scheduler.components[i];
                var data = {};
                var hasTweens = false;
                for (var key in component._currentTweens) {
                    var t = component._currentTweens[key];
                    if (now >= t.end) {
                        data[key] = t.to;
                        delete component._currentTweens[key];
                        t.fulfil();
                    } else {
                        hasTweens = true;
                        hasComponents = true;
                        if (now >= t.start) {
                            var p = (now - t.start) / t.duration;
                            data[key] = t.value(t.ease(p));
                        }
                    }
                }
                component._tweening = true;
                component.set(data);
                component._tweening = false;
                if (!hasTweens) {
                    scheduler.components.splice(i, 1);
                }
            }
            if (hasComponents) {
                requestAnimationFrame(scheduler.next);
            } else {
                scheduler.running = false;
            }
        },
    };
    function snap(to) {
        return function () {
            return to;
        };
    }
    function interpolate(a, b) {
        if (a === b || a !== a) {
            return snap(a);
        }
        var type = typeof a;
        if (type !== typeof b || Array.isArray(a) !== Array.isArray(b)) {
            throw new Error('Cannot interpolate values of different type');
        }
        if (Array.isArray(a)) {
            var arr_1 = b.map(function (bi, i) {
                return interpolate(a[i], bi);
            });
            return function (t) {
                return arr_1.map(function (fn) {
                    return fn(t);
                });
            };
        }
        if (type === 'object') {
            if (!a || !b) {
                throw new Error('Object cannot be null');
            }
            if (isDate$2(a) && isDate$2(b)) {
                a = a.getTime();
                b = b.getTime();
                var delta_1 = b - a;
                return function (t) {
                    return new Date(a + t * delta_1);
                };
            }
            var keys_1 = Object.keys(b);
            var interpolators_1 = {};
            var result_1 = {};
            keys_1.forEach(function (key) {
                interpolators_1[key] = interpolate(a[key], b[key]);
            });
            return function (t) {
                keys_1.forEach(function (key) {
                    result_1[key] = interpolators_1[key](t);
                });
                return result_1;
            };
        }
        if (type === 'number') {
            var delta_2 = b - a;
            return function (t) {
                return a + t * delta_2;
            };
        }
        throw new Error('Cannot interpolate ' + type + ' values');
    }
    function linear$1(x) {
        return x;
    }
    function tween(key, to, options) {
        var _this = this;
        if (options === void 0) {
            options = {};
        }
        if (!this._currentTweens) {
            this._currentTweens = Object.create(null);
            this._tweening = false;
            var set_1 = this.set;
            this.set = function (data) {
                if (!_this._tweening) {
                    for (var key_1 in data) {
                        if (_this._currentTweens[key_1]) {
                            _this._currentTweens[key_1].abort();
                        }
                    }
                }
                set_1.call(_this, data);
            };
        }
        if (this._currentTweens[key]) {
            this._currentTweens[key].abort();
        }
        var start = window.performance.now() + (options.delay || 0);
        var duration = options.duration || 400;
        var end = start + duration;
        var t = {
            key: key,
            value: (options.interpolate || interpolate)(this.get(key), to),
            to: to,
            start: start,
            end: end,
            duration: duration,
            ease: options.easing || linear$1,
            running: true,
            abort: function () {
                t.running = false;
                delete _this._currentTweens[key];
            },
        };
        this._currentTweens[key] = t;
        scheduler.add(this);
        var promise = new Promise(function (fulfil) {
            t.fulfil = fulfil;
        });
        promise.abort = t.abort;
        return promise;
    }

    function cubicOut(t) {
        var f = t - 1.0;
        return f * f * f + 1.0;
    }

    function setFocus($element) {
        $element = $element || document.body;

        // NOTE: if I need to repair any bugs, see:
        // https://stackoverflow.com/questions/1599660/which-html-elements-can-receive-focus

        // var xPos = window.scrollX
        // var yPos = window.scrollY
        var $$focusable = $element.querySelectorAll(
            'a[href], button, [role="button"], [tabindex]:not([tabindex="-1"])'
        );

        if ($$focusable.length) {
            $$focusable[0].focus();
        }
        // window.scrollTo(xPos, yPos)
    }

    // see: https://stackoverflow.com/questions/1248081/get-the-browser-viewport-dimensions-with-javascript
    function viewportDimensions() {
        var docEl = document.documentElement;
        return {
            width: Math.max(docEl.clientWidth, window.innerWidth || 0),
            height: Math.max(docEl.clientHeight, window.innerHeight || 0),
        };
    }

    /**
     * Get an element's distance from the top of the page
     * @param  {Node}   elem The element
     * @return {Number}      Distance from the top of the page
     * SEE: https://gomakethings.com/ditching-jquery/#get-distances-to-the-top-of-the-document
     */
    function getElementOffset(element) {
        var location = 0;
        if (element.offsetParent) {
            do {
                location += element.offsetTop;
                element = element.offsetParent;
            } while (element);
        }
        return location >= 0 ? location : 0;
    }

    /* client/source/app/components/ProgramsList.html generated by Svelte v1.50.0 */
    function loaded$1(json) {
        return !!json;
    }

    function filteredPrograms(loaded, json, programTypeFilter, collegeFilter) {
        if (loaded && json.programs && json.programs.length) {
            var programs = json.programs.slice();
            if (programTypeFilter !== 'all') {
                programs = _.filter(programs, {
                    programTypeFilter: programTypeFilter,
                });
            }
            if (collegeFilter !== 'all') {
                programs = _.filter(programs, { collegeKey: collegeFilter });
            }
            return programs;
        }
        return [];
    }

    function programGroups(filteredPrograms, json) {
        if (filteredPrograms && filteredPrograms.length) {
            var programs = _.groupBy(filteredPrograms, 'departmentKey');
            programs = _.map(programs, function (list, key) {
                var department = _.find(json.departments, { key: key });
                return {
                    title: department.value,
                    list: list,
                };
            });
            programs = _.orderBy(programs, 'title', 'asc');
            return programs;
        }
        return [];
    }

    function alphabeticPrograms(filteredPrograms) {
        return _.orderBy(filteredPrograms, 'title', 'asc');
    }

    function resultsCount(filteredPrograms) {
        return filteredPrograms.length;
    }

    function resultsClass(groupsOffset, windowHeight, yPos) {
        return groupsOffset >= windowHeight + yPos ? 'sticky' : '';
    }

    var methods = {
        tween: tween,
        setSizedVars: function setSizedVars() {
            this.set({ groupsOffset: getElementOffset(this.refs.groups) });
        },
        scrollToResults: function scrollToResults() {
            this.set({ yPosMirror: this.get('yPos') });
            this.tween('yPosMirror', getElementOffset(this.refs.groups), {
                duration: 1000,
                easing: cubicOut,
            });
            // focus first item
            setFocus(this.refs.groups);
        },
        checkState: function checkState(paramName, value, defaultValue) {
            var params = new URLSearchParams(window.location.search);
            var param = params.get(paramName);
            if (value) {
                params.set(paramName, value);
                history.replaceState(
                    null,
                    '',
                    window.location.pathname + '?' + params.toString()
                );
            } else {
                var setter = {};
                if (param) {
                    setter[paramName] = param;
                    this.set(setter);
                } else {
                    setter[paramName] = defaultValue;
                    this.set(setter);
                    params.set(paramName, defaultValue);
                    history.replaceState(
                        null,
                        '',
                        window.location.pathname + '?' + params.toString()
                    );
                }
            }
        },
    };

    function oncreate$2() {
        var this$1 = this;

        this.set({ yPos: window.pageYOffset });
        window.addEventListener('scroll', function () {
            return this$1.set({ yPos: window.pageYOffset });
        });

        // results button scroll handling
        this.observe('loaded', function (loaded) {
            if (loaded) {
                // we have to wait for the component to register in the DOM
                // because we use an `if` statement to render the DOM
                setTimeout(function () {
                    return this$1.setSizedVars();
                }, 0);
            }
        });

        // just some simple state management
        this.observe('programTypeFilter', function (programTypeFilter) {
            return this$1.checkState(
                'programTypeFilter',
                programTypeFilter,
                'all'
            );
        });
        this.observe('collegeFilter', function (collegeFilter) {
            return this$1.checkState('collegeFilter', collegeFilter, 'all');
        });
        this.observe('sortFilter', function (sortFilter) {
            return this$1.checkState('sortFilter', sortFilter, 'department');
        });

        // one time fetch
        fetch(this.get('url'))
            .then(function (response) {
                return response.json();
            })
            .then(function (json) {
                this$1.set({ json: json });
            });
        // TODO: handle errors gracefully?
        // .catch(ex => console.log('parsing failed', ex))

        // I hate this indirection, but it works...
        this.observe(
            'yPosMirror',
            function (yPos) {
                window.scrollTo(0, yPos);
            },
            { init: false }
        );
    }

    function create_main_fragment$2(state, component) {
        var if_block_anchor;

        function onwindowresize(event) {
            component.setSizedVars();
        }
        window.addEventListener('resize', onwindowresize);

        function onwindowresize_1(event) {
            component.set({
                windowHeight: this.innerHeight,
            });
        }
        window.addEventListener('resize', onwindowresize_1);

        var current_block_type = select_block_type_1(state);
        var if_block = current_block_type(state, component);

        return {
            c: function create() {
                if_block.c();
                if_block_anchor = createComment();
            },

            m: function mount(target, anchor) {
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type_1(state)) &&
                    if_block
                ) {
                    if_block.p(changed, state);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                window.removeEventListener('resize', onwindowresize);

                window.removeEventListener('resize', onwindowresize_1);

                if_block.d();
            },
        };
    }

    // (130:12) {{#each json.programTypeFilters as filter, index}}
    function create_each_block$1(
        state,
        programTypeFilters,
        filter,
        index,
        component
    ) {
        var div,
            input,
            input_value_value,
            input_id_value,
            text,
            label,
            text_1_value = filter.value,
            text_1,
            label_for_value;

        function input_change_handler() {
            component.set({ programTypeFilter: input.__value });
        }

        return {
            c: function create() {
                div = createElement('div');
                input = createElement('input');
                text = createText('\r\n        ');
                label = createElement('label');
                text_1 = createText(text_1_value);
                this.h();
            },

            h: function hydrate() {
                component._bindingGroups[0].push(input);
                addListener(input, 'change', input_change_handler);
                input.type = 'radio';
                input.__value = input_value_value = filter.key;
                input.value = input.__value;
                input.id = input_id_value = 'program-type-' + (index + 1);
                input.name = 'program-types';
                label.htmlFor = label_for_value = 'program-type-' + (index + 1);
                div.className = 'radio';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(input, div);

                input.checked = input.__value === state.programTypeFilter;

                appendNode(text, div);
                appendNode(label, div);
                appendNode(text_1, label);
            },

            p: function update(
                changed,
                state,
                programTypeFilters,
                filter,
                index
            ) {
                input.checked = input.__value === state.programTypeFilter;
                if (
                    changed.json &&
                    input_value_value !== (input_value_value = filter.key)
                ) {
                    input.__value = input_value_value;
                }

                input.value = input.__value;
                if (
                    changed.json &&
                    text_1_value !== (text_1_value = filter.value)
                ) {
                    text_1.data = text_1_value;
                }
            },

            u: function unmount() {
                detachNode(div);
            },

            d: function destroy$$1() {
                component._bindingGroups[0].splice(
                    component._bindingGroups[0].indexOf(input),
                    1
                );
                removeListener(input, 'change', input_change_handler);
            },
        };
    }

    // (143:12) {{#each json.colleges as college, index}}
    function create_each_block_1(state, colleges, college, index, component) {
        var div,
            input,
            input_value_value,
            input_id_value,
            text,
            label,
            text_1_value = college.value,
            text_1,
            label_for_value;

        function input_change_handler() {
            component.set({ collegeFilter: input.__value });
        }

        return {
            c: function create() {
                div = createElement('div');
                input = createElement('input');
                text = createText('\r\n        ');
                label = createElement('label');
                text_1 = createText(text_1_value);
                this.h();
            },

            h: function hydrate() {
                component._bindingGroups[1].push(input);
                addListener(input, 'change', input_change_handler);
                input.type = 'radio';
                input.__value = input_value_value = college.key;
                input.value = input.__value;
                input.id = input_id_value = 'college-' + (index + 1);
                input.name = 'colleges';
                label.htmlFor = label_for_value = 'college-' + (index + 1);
                div.className = 'radio';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(input, div);

                input.checked = input.__value === state.collegeFilter;

                appendNode(text, div);
                appendNode(label, div);
                appendNode(text_1, label);
            },

            p: function update(changed, state, colleges, college, index) {
                input.checked = input.__value === state.collegeFilter;
                if (
                    changed.json &&
                    input_value_value !== (input_value_value = college.key)
                ) {
                    input.__value = input_value_value;
                }

                input.value = input.__value;
                if (
                    changed.json &&
                    text_1_value !== (text_1_value = college.value)
                ) {
                    text_1.data = text_1_value;
                }
            },

            u: function unmount() {
                detachNode(div);
            },

            d: function destroy$$1() {
                component._bindingGroups[1].splice(
                    component._bindingGroups[1].indexOf(input),
                    1
                );
                removeListener(input, 'change', input_change_handler);
            },
        };
    }

    // (165:41) {{#each programGroups as programGroup, index}}
    function create_each_block_2(
        state,
        programGroups_1,
        programGroup,
        index,
        component
    ) {
        var div,
            h2,
            text_value = programGroup.title,
            text,
            text_1,
            ul;

        var list = programGroup.list;

        var each_blocks = [];

        for (var i = 0; i < list.length; i += 1) {
            each_blocks[i] = create_each_block_3(
                state,
                programGroups_1,
                programGroup,
                index,
                list,
                list[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                div = createElement('div');
                h2 = createElement('h2');
                text = createText(text_value);
                text_1 = createText('\r\n    ');
                ul = createElement('ul');

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }
                this.h();
            },

            h: function hydrate() {
                h2.className = 'h4 title';
                div.className = 'group fullwidth';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(h2, div);
                appendNode(text, h2);
                appendNode(text_1, div);
                appendNode(ul, div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(ul, null);
                }
            },

            p: function update(
                changed,
                state,
                programGroups_1,
                programGroup,
                index
            ) {
                if (
                    changed.programGroups &&
                    text_value !== (text_value = programGroup.title)
                ) {
                    text.data = text_value;
                }

                var list = programGroup.list;

                if (changed.programGroups) {
                    for (var i = 0; i < list.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                programGroups_1,
                                programGroup,
                                index,
                                list,
                                list[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block_3(
                                state,
                                programGroups_1,
                                programGroup,
                                index,
                                list,
                                list[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(ul, null);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = list.length;
                }
            },

            u: function unmount() {
                detachNode(div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);
            },
        };
    }

    // (168:8) {{#each programGroup.list as list}}
    function create_each_block_3(
        state,
        programGroups_1,
        programGroup,
        index,
        list,
        list_1,
        list_index,
        component
    ) {
        var li,
            a,
            text_value = list_1.title,
            text,
            a_href_value;

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                text = createText(text_value);
                this.h();
            },

            h: function hydrate() {
                a.href = a_href_value = list_1.url;
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
                appendNode(text, a);
            },

            p: function update(
                changed,
                state,
                programGroups_1,
                programGroup,
                index,
                list,
                list_1,
                list_index
            ) {
                if (
                    changed.programGroups &&
                    text_value !== (text_value = list_1.title)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.programGroups &&
                    a_href_value !== (a_href_value = list_1.url)
                ) {
                    a.href = a_href_value;
                }
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (176:8) {{#each alphabeticPrograms as program, index}}
    function create_each_block_4(
        state,
        alphabeticPrograms_1,
        program,
        index,
        component
    ) {
        var li,
            a,
            text_value = program.title,
            text,
            a_href_value;

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                text = createText(text_value);
                this.h();
            },

            h: function hydrate() {
                a.href = a_href_value = program.url;
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
                appendNode(text, a);
            },

            p: function update(
                changed,
                state,
                alphabeticPrograms_1,
                program,
                index
            ) {
                if (
                    changed.alphabeticPrograms &&
                    text_value !== (text_value = program.title)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.alphabeticPrograms &&
                    a_href_value !== (a_href_value = program.url)
                ) {
                    a.href = a_href_value;
                }
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (164:6) {{#if sortFilter === 'department'}}
    function create_if_block_1$1(state, component) {
        var div;

        var programGroups_1 = state.programGroups;

        var each_blocks = [];

        for (var i = 0; i < programGroups_1.length; i += 1) {
            each_blocks[i] = create_each_block_2(
                state,
                programGroups_1,
                programGroups_1[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                div = createElement('div');

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }
                this.h();
            },

            h: function hydrate() {
                div.className = 'groups fullwidth';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(div, null);
                }

                component.refs.groups = div;
            },

            p: function update(changed, state) {
                var programGroups_1 = state.programGroups;

                if (changed.programGroups) {
                    for (var i = 0; i < programGroups_1.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                programGroups_1,
                                programGroups_1[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block_2(
                                state,
                                programGroups_1,
                                programGroups_1[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(div, null);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = programGroups_1.length;
                }
            },

            u: function unmount() {
                detachNode(div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);

                if (component.refs.groups === div) {
                    component.refs.groups = null;
                }
            },
        };
    }

    // (172:6) {{else}}
    function create_if_block_2(state, component) {
        var div, div_1, h2, text_1, ul;

        var alphabeticPrograms_1 = state.alphabeticPrograms;

        var each_blocks = [];

        for (var i = 0; i < alphabeticPrograms_1.length; i += 1) {
            each_blocks[i] = create_each_block_4(
                state,
                alphabeticPrograms_1,
                alphabeticPrograms_1[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');
                h2 = createElement('h2');
                h2.textContent = '(Sorted by Alphabetical Order)';
                text_1 = createText('\r\n    ');
                ul = createElement('ul');

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }
                this.h();
            },

            h: function hydrate() {
                h2.className = 'h4 title';
                div_1.className = 'group';
                div.className = 'groups';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                appendNode(h2, div_1);
                appendNode(text_1, div_1);
                appendNode(ul, div_1);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(ul, null);
                }

                component.refs.groups = div;
            },

            p: function update(changed, state) {
                var alphabeticPrograms_1 = state.alphabeticPrograms;

                if (changed.alphabeticPrograms) {
                    for (var i = 0; i < alphabeticPrograms_1.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                alphabeticPrograms_1,
                                alphabeticPrograms_1[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block_4(
                                state,
                                alphabeticPrograms_1,
                                alphabeticPrograms_1[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(ul, null);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = alphabeticPrograms_1.length;
                }
            },

            u: function unmount() {
                detachNode(div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);

                if (component.refs.groups === div) {
                    component.refs.groups = null;
                }
            },
        };
    }

    // (122:78) {{#if loaded}}
    function create_if_block$1(state, component) {
        var div,
            div_1,
            fieldset,
            legend,
            text_1,
            div_2,
            input,
            text_2,
            label,
            text_4,
            text_7,
            div_3,
            fieldset_1,
            legend_1,
            text_9,
            div_4,
            input_1,
            text_10,
            label_1,
            text_12,
            text_15,
            div_5,
            fieldset_2,
            legend_2,
            text_17,
            div_6,
            input_2,
            text_18,
            label_2,
            text_21,
            div_7,
            input_3,
            text_22,
            label_3,
            text_27,
            button,
            span,
            text_28,
            text_29,
            button_class_value,
            text_30,
            if_block_anchor;

        function input_change_handler() {
            component.set({ programTypeFilter: input.__value });
        }

        var programTypeFilters = state.json.programTypeFilters;

        var each_blocks = [];

        for (var i = 0; i < programTypeFilters.length; i += 1) {
            each_blocks[i] = create_each_block$1(
                state,
                programTypeFilters,
                programTypeFilters[i],
                i,
                component
            );
        }

        function input_1_change_handler() {
            component.set({ collegeFilter: input_1.__value });
        }

        var colleges = state.json.colleges;

        var each_1_blocks = [];

        for (var i = 0; i < colleges.length; i += 1) {
            each_1_blocks[i] = create_each_block_1(
                state,
                colleges,
                colleges[i],
                i,
                component
            );
        }

        function input_2_change_handler() {
            component.set({ sortFilter: input_2.__value });
        }

        function input_3_change_handler() {
            component.set({ sortFilter: input_3.__value });
        }

        function click_handler(event) {
            component.scrollToResults();
        }

        var current_block_type = select_block_type$1(state);
        var if_block = current_block_type(state, component);

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');
                fieldset = createElement('fieldset');
                legend = createElement('legend');
                legend.textContent = 'Show Me';
                text_1 = createText('\r\n      ');
                div_2 = createElement('div');
                input = createElement('input');
                text_2 = createText('\r\n        ');
                label = createElement('label');
                label.textContent = 'All Program Types';
                text_4 = createText('\r\n      ');

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                text_7 = createText('\r\n  ');
                div_3 = createElement('div');
                fieldset_1 = createElement('fieldset');
                legend_1 = createElement('legend');
                legend_1.textContent = 'From';
                text_9 = createText('\r\n      ');
                div_4 = createElement('div');
                input_1 = createElement('input');
                text_10 = createText('\r\n        ');
                label_1 = createElement('label');
                label_1.textContent = 'All Colleges';
                text_12 = createText('\r\n      ');

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].c();
                }

                text_15 = createText('\r\n  ');
                div_5 = createElement('div');
                fieldset_2 = createElement('fieldset');
                legend_2 = createElement('legend');
                legend_2.textContent = 'Sorted By';
                text_17 = createText('\r\n      ');
                div_6 = createElement('div');
                input_2 = createElement('input');
                text_18 = createText('\r\n        ');
                label_2 = createElement('label');
                label_2.textContent = 'Department';
                text_21 = createText('\r\n      ');
                div_7 = createElement('div');
                input_3 = createElement('input');
                text_22 = createText('\r\n        ');
                label_3 = createElement('label');
                label_3.textContent = 'Alphabetical Order';
                text_27 = createText('\r\n  ');
                button = createElement('button');
                span = createElement('span');
                text_28 = createText(state.resultsCount);
                text_29 = createText(' Results');
                text_30 = createText('\r\n');
                if_block.c();
                if_block_anchor = createComment();
                this.h();
            },

            h: function hydrate() {
                legend.className = 'h6';
                component._bindingGroups[0].push(input);
                addListener(input, 'change', input_change_handler);
                input.id = 'program-type-0';
                input.type = 'radio';
                input.__value = 'all';
                input.value = input.__value;
                input.name = 'program-types';
                label.htmlFor = 'program-type-0';
                div_2.className = 'radio';
                div_1.className = 'control small-12 medium-4';
                legend_1.className = 'h6';
                component._bindingGroups[1].push(input_1);
                addListener(input_1, 'change', input_1_change_handler);
                input_1.id = 'college-0';
                input_1.type = 'radio';
                input_1.__value = 'all';
                input_1.value = input_1.__value;
                input_1.name = 'colleges';
                label_1.htmlFor = 'college-0';
                div_4.className = 'radio';
                div_3.className = 'control small-12 medium-4';
                legend_2.className = 'h6';
                component._bindingGroups[2].push(input_2);
                addListener(input_2, 'change', input_2_change_handler);
                input_2.id = 'sort-0';
                input_2.type = 'radio';
                input_2.__value = 'department';
                input_2.value = input_2.__value;
                input_2.name = 'sort';
                label_2.htmlFor = 'sort-0';
                div_6.className = 'radio';
                component._bindingGroups[2].push(input_3);
                addListener(input_3, 'change', input_3_change_handler);
                input_3.id = 'sort-1';
                input_3.type = 'radio';
                input_3.__value = 'alphabet';
                input_3.value = input_3.__value;
                input_3.name = 'sort';
                label_3.htmlFor = 'sort-1';
                div_7.className = 'radio';
                div_5.className = 'control small-12 medium-4';
                button.className = button_class_value =
                    'results ' + state.resultsClass;
                addListener(button, 'click', click_handler);
                div.className = 'controls grid-x grid-margin-x fullwidth';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                appendNode(fieldset, div_1);
                appendNode(legend, fieldset);
                appendNode(text_1, fieldset);
                appendNode(div_2, fieldset);
                appendNode(input, div_2);

                input.checked = input.__value === state.programTypeFilter;

                appendNode(text_2, div_2);
                appendNode(label, div_2);
                appendNode(text_4, div_2);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(fieldset, null);
                }

                appendNode(text_7, div);
                appendNode(div_3, div);
                appendNode(fieldset_1, div_3);
                appendNode(legend_1, fieldset_1);
                appendNode(text_9, fieldset_1);
                appendNode(div_4, fieldset_1);
                appendNode(input_1, div_4);

                input_1.checked = input_1.__value === state.collegeFilter;

                appendNode(text_10, div_4);
                appendNode(label_1, div_4);
                appendNode(text_12, div_4);

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].m(fieldset_1, null);
                }

                appendNode(text_15, div);
                appendNode(div_5, div);
                appendNode(fieldset_2, div_5);
                appendNode(legend_2, fieldset_2);
                appendNode(text_17, fieldset_2);
                appendNode(div_6, fieldset_2);
                appendNode(input_2, div_6);

                input_2.checked = input_2.__value === state.sortFilter;

                appendNode(text_18, div_6);
                appendNode(label_2, div_6);
                appendNode(text_21, fieldset_2);
                appendNode(div_7, fieldset_2);
                appendNode(input_3, div_7);

                input_3.checked = input_3.__value === state.sortFilter;

                appendNode(text_22, div_7);
                appendNode(label_3, div_7);
                appendNode(text_27, div);
                appendNode(button, div);
                appendNode(span, button);
                appendNode(text_28, span);
                appendNode(text_29, span);
                component.refs.results = button;
                appendNode(text_30, div);
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state) {
                input.checked = input.__value === state.programTypeFilter;

                var programTypeFilters = state.json.programTypeFilters;

                if (changed.json || changed.programTypeFilter) {
                    for (var i = 0; i < programTypeFilters.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                programTypeFilters,
                                programTypeFilters[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block$1(
                                state,
                                programTypeFilters,
                                programTypeFilters[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(fieldset, null);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = programTypeFilters.length;
                }

                input_1.checked = input_1.__value === state.collegeFilter;

                var colleges = state.json.colleges;

                if (changed.json || changed.collegeFilter) {
                    for (var i = 0; i < colleges.length; i += 1) {
                        if (each_1_blocks[i]) {
                            each_1_blocks[i].p(
                                changed,
                                state,
                                colleges,
                                colleges[i],
                                i
                            );
                        } else {
                            each_1_blocks[i] = create_each_block_1(
                                state,
                                colleges,
                                colleges[i],
                                i,
                                component
                            );
                            each_1_blocks[i].c();
                            each_1_blocks[i].m(fieldset_1, null);
                        }
                    }

                    for (; i < each_1_blocks.length; i += 1) {
                        each_1_blocks[i].u();
                        each_1_blocks[i].d();
                    }
                    each_1_blocks.length = colleges.length;
                }

                input_2.checked = input_2.__value === state.sortFilter;
                input_3.checked = input_3.__value === state.sortFilter;
                if (changed.resultsCount) {
                    text_28.data = state.resultsCount;
                }

                if (
                    changed.resultsClass &&
                    button_class_value !==
                        (button_class_value = 'results ' + state.resultsClass)
                ) {
                    button.className = button_class_value;
                }

                if (
                    current_block_type ===
                        (current_block_type = select_block_type$1(state)) &&
                    if_block
                ) {
                    if_block.p(changed, state);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                detachNode(div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].u();
                }

                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                component._bindingGroups[0].splice(
                    component._bindingGroups[0].indexOf(input),
                    1
                );
                removeListener(input, 'change', input_change_handler);

                destroyEach(each_blocks);

                component._bindingGroups[1].splice(
                    component._bindingGroups[1].indexOf(input_1),
                    1
                );
                removeListener(input_1, 'change', input_1_change_handler);

                destroyEach(each_1_blocks);

                component._bindingGroups[2].splice(
                    component._bindingGroups[2].indexOf(input_2),
                    1
                );
                removeListener(input_2, 'change', input_2_change_handler);
                component._bindingGroups[2].splice(
                    component._bindingGroups[2].indexOf(input_3),
                    1
                );
                removeListener(input_3, 'change', input_3_change_handler);
                removeListener(button, 'click', click_handler);
                if (component.refs.results === button) {
                    component.refs.results = null;
                }
                if_block.d();
            },
        };
    }

    // (180:13) {{else}}
    function create_if_block_3(state, component) {
        var loader = new Loader({
            root: component.root,
        });

        return {
            c: function create() {
                loader._fragment.c();
            },

            m: function mount(target, anchor) {
                loader._mount(target, anchor);
            },

            p: noop,

            u: function unmount() {
                loader._unmount();
            },

            d: function destroy$$1() {
                loader.destroy(false);
            },
        };
    }

    function select_block_type$1(state) {
        if (state.sortFilter === 'department') {
            return create_if_block_1$1;
        }
        return create_if_block_2;
    }

    function select_block_type_1(state) {
        if (state.loaded) {
            return create_if_block$1;
        }
        return create_if_block_3;
    }

    function ProgramsList(options) {
        init(this, options);
        this.refs = {};
        this._state = assign({}, options.data);
        this._state.windowHeight = window.innerHeight;
        this._recompute(
            {
                json: 1,
                loaded: 1,
                programTypeFilter: 1,
                collegeFilter: 1,
                filteredPrograms: 1,
                groupsOffset: 1,
                windowHeight: 1,
                yPos: 1,
            },
            this._state
        );
        this._bindingGroups = [[], [], []];

        var _oncreate = oncreate$2.bind(this);

        if (!options.root) {
            this._oncreate = [_oncreate];
            this._beforecreate = [];
            this._aftercreate = [];
        } else {
            this.root._oncreate.push(_oncreate);
        }

        this._fragment = create_main_fragment$2(this._state, this);

        if (options.target) {
            this._fragment.c();
            this._fragment.m(options.target, options.anchor || null);

            this._lock = true;
            callAll(this._beforecreate);
            callAll(this._oncreate);
            callAll(this._aftercreate);
            this._lock = false;
        }
    }

    assign(ProgramsList.prototype, methods, proto);

    ProgramsList.prototype._recompute = function _recompute(changed, state) {
        if (changed.json) {
            if (differs(state.loaded, (state.loaded = loaded$1(state.json)))) {
                changed.loaded = true;
            }
        }

        if (
            changed.loaded ||
            changed.json ||
            changed.programTypeFilter ||
            changed.collegeFilter
        ) {
            if (
                differs(
                    state.filteredPrograms,
                    (state.filteredPrograms = filteredPrograms(
                        state.loaded,
                        state.json,
                        state.programTypeFilter,
                        state.collegeFilter
                    ))
                )
            ) {
                changed.filteredPrograms = true;
            }
        }

        if (changed.filteredPrograms || changed.json) {
            if (
                differs(
                    state.programGroups,
                    (state.programGroups = programGroups(
                        state.filteredPrograms,
                        state.json
                    ))
                )
            ) {
                changed.programGroups = true;
            }
        }

        if (changed.filteredPrograms) {
            if (
                differs(
                    state.alphabeticPrograms,
                    (state.alphabeticPrograms = alphabeticPrograms(
                        state.filteredPrograms
                    ))
                )
            ) {
                changed.alphabeticPrograms = true;
            }
            if (
                differs(
                    state.resultsCount,
                    (state.resultsCount = resultsCount(state.filteredPrograms))
                )
            ) {
                changed.resultsCount = true;
            }
        }

        if (changed.groupsOffset || changed.windowHeight || changed.yPos) {
            if (
                differs(
                    state.resultsClass,
                    (state.resultsClass = resultsClass(
                        state.groupsOffset,
                        state.windowHeight,
                        state.yPos
                    ))
                )
            ) {
                changed.resultsClass = true;
            }
        }
    };

    /**
     * Computed navItems property for list pagination
     */
    function navItems(filteredItems, page, navRange) {
        var length = navRange.length;
        var pageIndex = page - 1;

        // some crazy pagination gatekeeping here, watch out...

        //   1  (2)  3   4   5				✅
        //   1   …   3  (4)  5   …   7		✅
        //   1  (2)  3   …   6				✅
        //   1   2  (3)  4   …   6			✅
        //   1   …   3  (4)  5   6			✅
        //       1   …   4  (5)  6			✅

        var navItems = _.map(navRange, function (value, index) {
            var navItem = { value: value };
            if (index === pageIndex) {
                navItem.on = true;
            }
            if (length > 5) {
                // more than 5 pages means put `...` somewhere
                navItem.use = false; // default
                if (index === pageIndex - 1) {
                    navItem.use = true;
                }
                if (index === pageIndex) {
                    navItem.use = true;
                }
                if (index === pageIndex + 1) {
                    navItem.use = true;
                }
            } else {
                // five or less just show them all
                navItem.use = true;
            }
            return navItem;
        });
        if (length > 5) {
            if (page === 1) {
                navItems[2].use = true;
                navItems[3].etc = true;
                navItems[length - 1].use = true;
            } else if (page === 2) {
                navItems[4].etc = true;
                navItems[length - 1].use = true;
            } else if (page === 3) {
                navItems[0].use = true;
                navItems[4].etc = true;
                navItems[length - 1].use = true;
            } else if (pageIndex === length - 1) {
                navItems[0].use = true;
                navItems[length - 4].etc = true;
                navItems[length - 3].use = true;
            } else if (pageIndex === length - 2) {
                navItems[0].use = true;
                navItems[length - 4].etc = true;
            } else if (pageIndex === length - 3) {
                navItems[0].use = true;
                navItems[length - 5].etc = true;
                navItems[length - 1].use = true;
            } else {
                navItems[0].use = true;
                navItems[1].etc = true;
                navItems[length - 2].etc = true;
                navItems[length - 1].use = true;
            }
        }

        navItems = _.filter(navItems, function (item) {
            return item.use || item.etc || item.on;
        });

        return navItems;
    }

    /**
     * Navigation helper for lists
     */
    function navigate(event, direction) {
        event.preventDefault();
        var page = this.get('page');
        if (direction === 'previous') {
            --page;
        } else if (direction === 'next') {
            ++page;
        } else {
            page = direction;
        }
        this.set({ page: page });

        // scroll up
        this.set({ yPosMirror: this.get('yPos') });
        this.tween('yPosMirror', 0, {
            duration: 1000,
            easing: cubicOut,
        });
        // focus first item
        setFocus(this.refs.list);
    }

    /**
     * Helper for checking state management on lists
     */
    function checkState(paramName, value, defaultValue) {
        var params = new URLSearchParams(window.location.search);
        var param = params.get(paramName);
        if (_.isNil(value)) {
            var setter = {};
            if (_.isNil(param)) {
                setter[paramName] = defaultValue;
                this.set(setter);
                params.set(paramName, defaultValue);
                history.replaceState(
                    null,
                    '',
                    window.location.pathname + '?' + params.toString()
                );
            } else {
                setter[paramName] = param;
                this.set(setter);
            }
        } else {
            params.set(paramName, value);
            history.replaceState(
                null,
                '',
                window.location.pathname + '?' + params.toString()
            );
        }
    }

    /* client/source/app/components/NewsList.html generated by Svelte v1.50.0 */
    function filteredItems(items, tag) {
        // filter, truncate, and sort
        if (tag) {
            items = _.filter(items, function (item) {
                var lowerTags = _.map(item.tags, function (item) {
                    return item.toLowerCase();
                });
                return lowerTags.indexOf(tag.toLowerCase()) > -1;
            });
        }
        items = _.map(items, function (item) {
            if (item.summary && item.summary.length > 200) {
                var pieces = item.summary.slice(0, 200).split(' ');
                pieces.pop();
                item.summary = pieces.join(' ') + ' . . .';
            }
            return item;
        });
        // return items
        return _.orderBy(items, 'timestamp', 'desc');
    }

    function paginatedItems(filteredItems, page, pagesize) {
        var start = (page - 1) * pagesize;
        filteredItems = filteredItems.slice(start, start + pagesize);
        return filteredItems;
    }

    function navRange(filteredItems, pagesize) {
        return _.range(1, filteredItems.length / pagesize + 1);
    }

    function navItems_1(filteredItems, page, navRange) {
        return navItems(filteredItems, page, navRange);
    }

    function data$1() {
        return {
            pagesize: 10,
        };
    }

    var methods$1 = {
        tween: tween,
        navigate: navigate,
        checkState: checkState,
    };

    function oncreate$3() {
        var this$1 = this;

        // just some simple state management
        this.observe('tag', function (tag) {
            return this$1.checkState('tag', tag, '');
        });
        this.observe('page', function (page) {
            return this$1.checkState('page', page, 1);
        });

        // one time fetch
        fetch(this.get('url'))
            .then(function (response) {
                return response.json();
            })
            .then(function (json) {
                return this$1.set({ items: json });
            });
        // TODO: handle errors gracefully?
        // .catch(ex => console.log('parsing failed', ex))

        // I hate this indirection, but it works...
        this.observe(
            'yPosMirror',
            function (yPos) {
                this$1.set({ yPos: yPos });
            },
            { init: false }
        );
    }

    function create_main_fragment$3(state, component) {
        var window_updating = false,
            text,
            div,
            div_1,
            text_1;

        function onwindowscroll(event) {
            window_updating = true;

            component.set({
                yPos: this.scrollY,
            });
            window_updating = false;
        }
        window.addEventListener('scroll', onwindowscroll);

        component.observe('yPos', function (y) {
            if (window_updating) {
                return;
            }
            window.scrollTo(window.scrollX, y);
        });

        var if_block = state.tag && create_if_block$2(state, component);

        var current_block_type = select_block_type_1$1(state);
        var if_block_1 = current_block_type(state, component);

        var if_block_2 =
            state.navItems.length > 1 &&
            state.paginatedItems.length &&
            create_if_block_5(state, component);

        return {
            c: function create() {
                if (if_block) {
                    if_block.c();
                }
                text = createText('\r\n');
                div = createElement('div');
                div_1 = createElement('div');
                if_block_1.c();
                text_1 = createText('\r\n  ');
                if (if_block_2) {
                    if_block_2.c();
                }
                this.h();
            },

            h: function hydrate() {
                div_1.className = 'list';
                div.className = 'news-list media-objects block';
            },

            m: function mount(target, anchor) {
                if (if_block) {
                    if_block.m(target, anchor);
                }
                insertNode(text, target, anchor);
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                if_block_1.m(div_1, null);
                appendNode(text_1, div_1);
                if (if_block_2) {
                    if_block_2.m(div, null);
                }
                component.refs.list = div;
            },

            p: function update(changed, state) {
                if (state.tag) {
                    if (if_block) {
                        if_block.p(changed, state);
                    } else {
                        if_block = create_if_block$2(state, component);
                        if_block.c();
                        if_block.m(text.parentNode, text);
                    }
                } else if (if_block) {
                    if_block.u();
                    if_block.d();
                    if_block = null;
                }

                if (
                    current_block_type ===
                        (current_block_type = select_block_type_1$1(state)) &&
                    if_block_1
                ) {
                    if_block_1.p(changed, state);
                } else {
                    if_block_1.u();
                    if_block_1.d();
                    if_block_1 = current_block_type(state, component);
                    if_block_1.c();
                    if_block_1.m(div_1, text_1);
                }

                if (state.navItems.length > 1 && state.paginatedItems.length) {
                    if (if_block_2) {
                        if_block_2.p(changed, state);
                    } else {
                        if_block_2 = create_if_block_5(state, component);
                        if_block_2.c();
                        if_block_2.m(div, null);
                    }
                } else if (if_block_2) {
                    if_block_2.u();
                    if_block_2.d();
                    if_block_2 = null;
                }
            },

            u: function unmount() {
                if (if_block) {
                    if_block.u();
                }
                detachNode(text);
                detachNode(div);
                if_block_1.u();
                if (if_block_2) {
                    if_block_2.u();
                }
            },

            d: function destroy$$1() {
                window.removeEventListener('scroll', onwindowscroll);

                if (if_block) {
                    if_block.d();
                }
                if_block_1.d();
                if (if_block_2) {
                    if_block_2.d();
                }
                if (component.refs.list === div) {
                    component.refs.list = null;
                }
            },
        };
    }

    // (74:39) {{#if tag}}
    function create_if_block$2(state, component) {
        var div, div_1, h2, text, text_1, text_2, button;

        function click_handler(event) {
            component.set({ page: 1, tag: '' });
        }

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');
                h2 = createElement('h2');
                text = createText('Results For: ');
                text_1 = createText(state.tag);
                text_2 = createText('\r\n    ');
                button = createElement('button');
                button.textContent = 'All News';
                this.h();
            },

            h: function hydrate() {
                h2.className = 'h6 results';
                button.className = 'button';
                setAttribute(button, 'aria-label', 'Load all news');
                addListener(button, 'click', click_handler);
                div_1.className = 'wrap';
                div.className = 'listing-toolbar fullwidth';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                appendNode(h2, div_1);
                appendNode(text, h2);
                appendNode(text_1, h2);
                appendNode(text_2, div_1);
                appendNode(button, div_1);
            },

            p: function update(changed, state) {
                if (changed.tag) {
                    text_1.data = state.tag;
                }
            },

            u: function unmount() {
                detachNode(div);
            },

            d: function destroy$$1() {
                removeListener(button, 'click', click_handler);
            },
        };
    }

    // (82:49) {{#each paginatedItems as item}}
    function create_each_block$2(
        state,
        paginatedItems_1,
        item,
        item_index,
        component
    ) {
        var div,
            div_1,
            text_1,
            div_2,
            div_3,
            text_2_value = item.timestampFormatted,
            text_2,
            text_3,
            h2,
            a,
            text_4_value = item.title,
            text_4,
            a_href_value,
            text_5,
            div_4,
            text_6_value = item.summary,
            text_6;

        var current_block_type = select_block_type$2(
            state,
            paginatedItems_1,
            item,
            item_index
        );
        var if_block = current_block_type(
            state,
            paginatedItems_1,
            item,
            item_index,
            component
        );

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');
                if_block.c();
                text_1 = createText('\r\n      ');
                div_2 = createElement('div');
                div_3 = createElement('div');
                text_2 = createText(text_2_value);
                text_3 = createText('\r\n        ');
                h2 = createElement('h2');
                a = createElement('a');
                text_4 = createText(text_4_value);
                text_5 = createText('\r\n        ');
                div_4 = createElement('div');
                text_6 = createText(text_6_value);
                this.h();
            },

            h: function hydrate() {
                div_1.className = 'img media-object-section';
                div_3.className = 'date';
                a.href = a_href_value = item.url;
                h2.className = 'h6 title';
                div_4.className = 'body';
                div_2.className = 'content media-object-section';
                div.className = 'media-object stack-for-small';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                if_block.m(div_1, null);
                appendNode(text_1, div);
                appendNode(div_2, div);
                appendNode(div_3, div_2);
                appendNode(text_2, div_3);
                appendNode(text_3, div_2);
                appendNode(h2, div_2);
                appendNode(a, h2);
                appendNode(text_4, a);
                appendNode(text_5, div_2);
                appendNode(div_4, div_2);
                appendNode(text_6, div_4);
            },

            p: function update(
                changed,
                state,
                paginatedItems_1,
                item,
                item_index
            ) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type$2(
                            state,
                            paginatedItems_1,
                            item,
                            item_index
                        )) &&
                    if_block
                ) {
                    if_block.p(
                        changed,
                        state,
                        paginatedItems_1,
                        item,
                        item_index
                    );
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(
                        state,
                        paginatedItems_1,
                        item,
                        item_index,
                        component
                    );
                    if_block.c();
                    if_block.m(div_1, null);
                }

                if (
                    changed.paginatedItems &&
                    text_2_value !== (text_2_value = item.timestampFormatted)
                ) {
                    text_2.data = text_2_value;
                }

                if (
                    changed.paginatedItems &&
                    text_4_value !== (text_4_value = item.title)
                ) {
                    text_4.data = text_4_value;
                }

                if (
                    changed.paginatedItems &&
                    a_href_value !== (a_href_value = item.url)
                ) {
                    a.href = a_href_value;
                }

                if (
                    changed.paginatedItems &&
                    text_6_value !== (text_6_value = item.summary)
                ) {
                    text_6.data = text_6_value;
                }
            },

            u: function unmount() {
                detachNode(div);
                if_block.u();
            },

            d: function destroy$$1() {
                if_block.d();
            },
        };
    }

    // (84:44) {{#if item.image}}
    function create_if_block_2$1(
        state,
        paginatedItems_1,
        item,
        item_index,
        component
    ) {
        var img, img_src_value, img_alt_value;

        return {
            c: function create() {
                img = createElement('img');
                this.h();
            },

            h: function hydrate() {
                img.src = img_src_value = item.image;
                img.alt = img_alt_value = item.imageAlt;
            },

            m: function mount(target, anchor) {
                insertNode(img, target, anchor);
            },

            p: function update(
                changed,
                state,
                paginatedItems_1,
                item,
                item_index
            ) {
                if (
                    changed.paginatedItems &&
                    img_src_value !== (img_src_value = item.image)
                ) {
                    img.src = img_src_value;
                }

                if (
                    changed.paginatedItems &&
                    img_alt_value !== (img_alt_value = item.imageAlt)
                ) {
                    img.alt = img_alt_value;
                }
            },

            u: function unmount() {
                detachNode(img);
            },

            d: noop,
        };
    }

    // (84:112) {{else}}
    function create_if_block_3$1(
        state,
        paginatedItems_1,
        item,
        item_index,
        component
    ) {
        var img;

        return {
            c: function create() {
                img = createElement('img');
                this.h();
            },

            h: function hydrate() {
                img.src = 'https://dummyimage.com/333x187/f2f3f2/f2f3f2.png';
                setAttribute(img, 'aria-hidden', 'true');
                img.alt = '';
            },

            m: function mount(target, anchor) {
                insertNode(img, target, anchor);
            },

            p: noop,

            u: function unmount() {
                detachNode(img);
            },

            d: noop,
        };
    }

    // (82:20) {{#if paginatedItems.length}}
    function create_if_block_1$2(state, component) {
        var each_anchor;

        var paginatedItems_1 = state.paginatedItems;

        var each_blocks = [];

        for (var i = 0; i < paginatedItems_1.length; i += 1) {
            each_blocks[i] = create_each_block$2(
                state,
                paginatedItems_1,
                paginatedItems_1[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                each_anchor = createComment();
            },

            m: function mount(target, anchor) {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(target, anchor);
                }

                insertNode(each_anchor, target, anchor);
            },

            p: function update(changed, state) {
                var paginatedItems_1 = state.paginatedItems;

                if (changed.paginatedItems) {
                    for (var i = 0; i < paginatedItems_1.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                paginatedItems_1,
                                paginatedItems_1[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block$2(
                                state,
                                paginatedItems_1,
                                paginatedItems_1[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(
                                each_anchor.parentNode,
                                each_anchor
                            );
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = paginatedItems_1.length;
                }
            },

            u: function unmount() {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                detachNode(each_anchor);
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);
            },
        };
    }

    // (91:19) {{else}}
    function create_if_block_4(state, component) {
        var loader = new Loader({
            root: component.root,
        });

        return {
            c: function create() {
                loader._fragment.c();
            },

            m: function mount(target, anchor) {
                loader._mount(target, anchor);
            },

            p: noop,

            u: function unmount() {
                loader._unmount();
            },

            d: function destroy$$1() {
                loader.destroy(false);
            },
        };
    }

    // (95:27) {{#if page <= 1}}
    function create_if_block_6(state, component) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                li.innerHTML = '<span class="show-for-sr">Previous page</span>';
                this.h();
            },

            h: function hydrate() {
                li.className = 'pagination-previous disabled';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (96:98) {{else}}
    function create_if_block_7(state, component) {
        var li, a;

        function click_handler(event) {
            component.navigate(event, 'previous');
        }

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                a.innerHTML = '<span class="show-for-sr">Previous page</span>';
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(a, 'aria-label', 'Previous page');
                addListener(a, 'click', click_handler);
                li.className = 'pagination-previous';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler);
            },
        };
    }

    // (97:178) {{#each navItems as item}}
    function create_each_block_1$1(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var if_block_anchor;

        var current_block_type = select_block_type_3(
            state,
            navItems_2,
            item,
            item_index
        );
        var if_block = current_block_type(
            state,
            navItems_2,
            item,
            item_index,
            component
        );

        return {
            c: function create() {
                if_block.c();
                if_block_anchor = createComment();
            },

            m: function mount(target, anchor) {
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type_3(
                            state,
                            navItems_2,
                            item,
                            item_index
                        )) &&
                    if_block
                ) {
                    if_block.p(changed, state, navItems_2, item, item_index);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(
                        state,
                        navItems_2,
                        item,
                        item_index,
                        component
                    );
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                if_block.d();
            },
        };
    }

    // (97:204) {{#if item.on}}
    function create_if_block_8(state, navItems_2, item, item_index, component) {
        var li,
            span,
            text_1_value = item.value,
            text_1;

        return {
            c: function create() {
                li = createElement('li');
                span = createElement('span');
                span.textContent = "You're on page ";
                text_1 = createText(text_1_value);
                this.h();
            },

            h: function hydrate() {
                span.className = 'show-for-sr';
                li.className = 'current';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(span, li);
                appendNode(text_1, li);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    changed.navItems &&
                    text_1_value !== (text_1_value = item.value)
                ) {
                    text_1.data = text_1_value;
                }
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (98:112)
    function create_if_block_9(state, navItems_2, item, item_index, component) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                this.h();
            },

            h: function hydrate() {
                li.className = 'ellipsis';
                setAttribute(li, 'aria-hidden', 'true');
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            p: noop,

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (99:51) {{else}}
    function create_if_block_10(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var li,
            a,
            text_value = item.value,
            text,
            a_aria_label_value;

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                text = createText(text_value);
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(
                    a,
                    'aria-label',
                    (a_aria_label_value = 'Page ' + item.value)
                );
                addListener(a, 'click', click_handler);

                a._svelte = {
                    component: component,
                    navItems_2: navItems_2,
                    item_index: item_index,
                };
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
                appendNode(text, a);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    changed.navItems &&
                    text_value !== (text_value = item.value)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.navItems &&
                    a_aria_label_value !==
                        (a_aria_label_value = 'Page ' + item.value)
                ) {
                    setAttribute(a, 'aria-label', a_aria_label_value);
                }

                a._svelte.navItems_2 = navItems_2;
                a._svelte.item_index = item_index;
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler);
            },
        };
    }

    // (100:133) {{#if page >= navRange.length}}
    function create_if_block_11(state, component) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                li.innerHTML = '<span class="show-for-sr">Next page</span>';
                this.h();
            },

            h: function hydrate() {
                li.className = 'pagination-next disabled';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (101:90) {{else}}
    function create_if_block_12(state, component) {
        var li, a;

        function click_handler_1(event) {
            component.navigate(event, 'next');
        }

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                a.innerHTML = '<span class="show-for-sr">Next page</span>';
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(a, 'aria-label', 'Next page');
                addListener(a, 'click', click_handler_1);
                li.className = 'pagination-next';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler_1);
            },
        };
    }

    // (93:8) {{#if navItems.length > 1 && paginatedItems.length}}
    function create_if_block_5(state, component) {
        var nav, ul, if_block_anchor, each_anchor;

        var current_block_type = select_block_type_2(state);
        var if_block = current_block_type(state, component);

        var navItems_2 = state.navItems;

        var each_blocks = [];

        for (var i = 0; i < navItems_2.length; i += 1) {
            each_blocks[i] = create_each_block_1$1(
                state,
                navItems_2,
                navItems_2[i],
                i,
                component
            );
        }

        var current_block_type_1 = select_block_type_4(state);
        var if_block_1 = current_block_type_1(state, component);

        return {
            c: function create() {
                nav = createElement('nav');
                ul = createElement('ul');
                if_block.c();
                if_block_anchor = createComment();

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                each_anchor = createComment();
                if_block_1.c();
                this.h();
            },

            h: function hydrate() {
                ul.className = 'pagination';
                nav.className = 'list-navigation';
                setAttribute(nav, 'role', 'navigation');
                setAttribute(nav, 'aria-label', 'News list pagination');
            },

            m: function mount(target, anchor) {
                insertNode(nav, target, anchor);
                appendNode(ul, nav);
                if_block.m(ul, null);
                appendNode(if_block_anchor, ul);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(ul, null);
                }

                appendNode(each_anchor, ul);
                if_block_1.m(ul, null);
            },

            p: function update(changed, state) {
                if (
                    current_block_type !==
                    (current_block_type = select_block_type_2(state))
                ) {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(ul, if_block_anchor);
                }

                var navItems_2 = state.navItems;

                if (changed.navItems) {
                    for (var i = 0; i < navItems_2.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                navItems_2,
                                navItems_2[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block_1$1(
                                state,
                                navItems_2,
                                navItems_2[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(ul, each_anchor);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = navItems_2.length;
                }

                if (
                    current_block_type_1 !==
                    (current_block_type_1 = select_block_type_4(state))
                ) {
                    if_block_1.u();
                    if_block_1.d();
                    if_block_1 = current_block_type_1(state, component);
                    if_block_1.c();
                    if_block_1.m(ul, null);
                }
            },

            u: function unmount() {
                detachNode(nav);
                if_block.u();

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                if_block_1.u();
            },

            d: function destroy$$1() {
                if_block.d();

                destroyEach(each_blocks);

                if_block_1.d();
            },
        };
    }

    function select_block_type$2(state, paginatedItems_1, item, item_index) {
        if (item.image) {
            return create_if_block_2$1;
        }
        return create_if_block_3$1;
    }

    function select_block_type_1$1(state) {
        if (state.paginatedItems.length) {
            return create_if_block_1$2;
        }
        return create_if_block_4;
    }

    function select_block_type_2(state) {
        if (state.page <= 1) {
            return create_if_block_6;
        }
        return create_if_block_7;
    }

    function click_handler(event) {
        var component = this._svelte.component;
        var navItems_2 = this._svelte.navItems_2,
            item_index = this._svelte.item_index,
            item = navItems_2[item_index];
        component.navigate(event, item.value);
    }

    function select_block_type_3(state, navItems_2, item, item_index) {
        if (item.on) {
            return create_if_block_8;
        }
        if (item.etc) {
            return create_if_block_9;
        }
        return create_if_block_10;
    }

    function select_block_type_4(state) {
        if (state.page >= state.navRange.length) {
            return create_if_block_11;
        }
        return create_if_block_12;
    }

    function NewsList(options) {
        init(this, options);
        this.refs = {};
        this._state = assign(data$1(), options.data);
        this._state.yPos = window.scrollY;
        this._recompute(
            {
                items: 1,
                tag: 1,
                filteredItems: 1,
                page: 1,
                pagesize: 1,
                navRange: 1,
            },
            this._state
        );

        var _oncreate = oncreate$3.bind(this);

        if (!options.root) {
            this._oncreate = [_oncreate];
            this._beforecreate = [];
            this._aftercreate = [];
        } else {
            this.root._oncreate.push(_oncreate);
        }

        this._fragment = create_main_fragment$3(this._state, this);

        if (options.target) {
            this._fragment.c();
            this._fragment.m(options.target, options.anchor || null);

            this._lock = true;
            callAll(this._beforecreate);
            callAll(this._oncreate);
            callAll(this._aftercreate);
            this._lock = false;
        }
    }

    assign(NewsList.prototype, methods$1, proto);

    NewsList.prototype._recompute = function _recompute(changed, state) {
        if (changed.items || changed.tag) {
            if (
                differs(
                    state.filteredItems,
                    (state.filteredItems = filteredItems(
                        state.items,
                        state.tag
                    ))
                )
            ) {
                changed.filteredItems = true;
            }
        }

        if (changed.filteredItems || changed.page || changed.pagesize) {
            if (
                differs(
                    state.paginatedItems,
                    (state.paginatedItems = paginatedItems(
                        state.filteredItems,
                        state.page,
                        state.pagesize
                    ))
                )
            ) {
                changed.paginatedItems = true;
            }
        }

        if (changed.filteredItems || changed.pagesize) {
            if (
                differs(
                    state.navRange,
                    (state.navRange = navRange(
                        state.filteredItems,
                        state.pagesize
                    ))
                )
            ) {
                changed.navRange = true;
            }
        }

        if (changed.filteredItems || changed.page || changed.navRange) {
            if (
                differs(
                    state.navItems,
                    (state.navItems = navItems_1(
                        state.filteredItems,
                        state.page,
                        state.navRange
                    ))
                )
            ) {
                changed.navItems = true;
            }
        }
    };

    /* client/source/app/components/EventsList.html generated by Svelte v1.50.0 */
    function filteredItems$1(items, tag) {
        // filter and sort
        if (tag) {
            items = _.filter(items, function (item) {
                var lowerTags = _.map(item.tags, function (item) {
                    return item.toLowerCase();
                });
                return lowerTags.indexOf(tag.toLowerCase()) > -1;
            });
        }
        return _.sortBy(items, 'timestamp');
    }

    function paginatedItems$1(filteredItems, page, pagesize) {
        var start = (page - 1) * pagesize;
        filteredItems = filteredItems.slice(start, start + pagesize);
        return filteredItems;
    }

    function navRange$1(filteredItems, pagesize) {
        return _.range(1, filteredItems.length / pagesize + 1);
    }

    function navItems_1$1(filteredItems, page, navRange) {
        return navItems(filteredItems, page, navRange);
    }

    function data$2() {
        return {
            pagesize: 10,
        };
    }

    var methods$2 = {
        tween: tween,
        navigate: navigate,
        checkState: checkState,
    };

    function oncreate$4() {
        var this$1 = this;

        // just some simple state management
        this.observe('tag', function (tag) {
            return this$1.checkState('tag', tag, '');
        });
        this.observe('page', function (page) {
            return this$1.checkState('page', page, 1);
        });

        // one time fetch
        fetch(this.get('url'))
            .then(function (response) {
                return response.json();
            })
            .then(function (json) {
                return this$1.set({ items: json });
            })
            // TODO: handle errors gracefully?
            .catch(function (ex) {
                return console.log('parsing failed', ex);
            });

        // I hate this indirection, but it works...
        this.observe(
            'yPosMirror',
            function (yPos) {
                this$1.set({ yPos: yPos });
            },
            { init: false }
        );
    }

    function create_main_fragment$4(state, component) {
        var window_updating = false,
            text,
            div,
            ul;

        function onwindowscroll(event) {
            window_updating = true;

            component.set({
                yPos: this.scrollY,
            });
            window_updating = false;
        }
        window.addEventListener('scroll', onwindowscroll);

        component.observe('yPos', function (y) {
            if (window_updating) {
                return;
            }
            window.scrollTo(window.scrollX, y);
        });

        var if_block = state.tag && create_if_block$3(state, component);

        var current_block_type = select_block_type$3(state);
        var if_block_1 = current_block_type(state, component);

        var if_block_2 =
            state.navItems.length > 1 &&
            state.paginatedItems.length &&
            create_if_block_3$2(state, component);

        return {
            c: function create() {
                if (if_block) {
                    if_block.c();
                }
                text = createText('\r\n');
                div = createElement('div');
                ul = createElement('ul');
                if_block_1.c();
                if (if_block_2) {
                    if_block_2.c();
                }
                this.h();
            },

            h: function hydrate() {
                ul.className = 'list';
                div.className = 'events-list media-objects block';
            },

            m: function mount(target, anchor) {
                if (if_block) {
                    if_block.m(target, anchor);
                }
                insertNode(text, target, anchor);
                insertNode(div, target, anchor);
                appendNode(ul, div);
                if_block_1.m(ul, null);
                if (if_block_2) {
                    if_block_2.m(div, null);
                }
                component.refs.list = div;
            },

            p: function update(changed, state) {
                if (state.tag) {
                    if (if_block) {
                        if_block.p(changed, state);
                    } else {
                        if_block = create_if_block$3(state, component);
                        if_block.c();
                        if_block.m(text.parentNode, text);
                    }
                } else if (if_block) {
                    if_block.u();
                    if_block.d();
                    if_block = null;
                }

                if (
                    current_block_type ===
                        (current_block_type = select_block_type$3(state)) &&
                    if_block_1
                ) {
                    if_block_1.p(changed, state);
                } else {
                    if_block_1.u();
                    if_block_1.d();
                    if_block_1 = current_block_type(state, component);
                    if_block_1.c();
                    if_block_1.m(ul, null);
                }

                if (state.navItems.length > 1 && state.paginatedItems.length) {
                    if (if_block_2) {
                        if_block_2.p(changed, state);
                    } else {
                        if_block_2 = create_if_block_3$2(state, component);
                        if_block_2.c();
                        if_block_2.m(div, null);
                    }
                } else if (if_block_2) {
                    if_block_2.u();
                    if_block_2.d();
                    if_block_2 = null;
                }
            },

            u: function unmount() {
                if (if_block) {
                    if_block.u();
                }
                detachNode(text);
                detachNode(div);
                if_block_1.u();
                if (if_block_2) {
                    if_block_2.u();
                }
            },

            d: function destroy$$1() {
                window.removeEventListener('scroll', onwindowscroll);

                if (if_block) {
                    if_block.d();
                }
                if_block_1.d();
                if (if_block_2) {
                    if_block_2.d();
                }
                if (component.refs.list === div) {
                    component.refs.list = null;
                }
            },
        };
    }

    // (65:39) {{#if tag}}
    function create_if_block$3(state, component) {
        var div, div_1, h2, text, text_1, text_2, button;

        function click_handler(event) {
            component.set({ page: 1, tag: '' });
        }

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');
                h2 = createElement('h2');
                text = createText('Events Tagged as: ');
                text_1 = createText(state.tag);
                text_2 = createText('\r\n    ');
                button = createElement('button');
                button.textContent = 'All Events';
                this.h();
            },

            h: function hydrate() {
                h2.className = 'h6 results';
                button.className = 'button';
                setAttribute(button, 'aria-label', 'Load all events');
                addListener(button, 'click', click_handler);
                div_1.className = 'wrap';
                div.className = 'listing-toolbar fullwidth';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                appendNode(h2, div_1);
                appendNode(text, h2);
                appendNode(text_1, h2);
                appendNode(text_2, div_1);
                appendNode(button, div_1);
            },

            p: function update(changed, state) {
                if (changed.tag) {
                    text_1.data = state.tag;
                }
            },

            u: function unmount() {
                detachNode(div);
            },

            d: function destroy$$1() {
                removeListener(button, 'click', click_handler);
            },
        };
    }

    // (73:48) {{#each paginatedItems as item}}
    function create_each_block$3(
        state,
        paginatedItems_1,
        item,
        item_index,
        component
    ) {
        var li,
            div,
            div_1,
            text_value = item.month,
            text,
            text_1,
            div_2,
            text_2_value = item.date,
            text_2,
            text_4,
            div_3,
            div_4,
            text_5_value = item.timestampFormatted,
            text_5,
            text_6,
            h2,
            a,
            text_7_value = item.title,
            text_7,
            a_href_value,
            text_8,
            div_5,
            text_9_value = item.summary,
            text_9;

        return {
            c: function create() {
                li = createElement('li');
                div = createElement('div');
                div_1 = createElement('div');
                text = createText(text_value);
                text_1 = createText('\r\n        ');
                div_2 = createElement('div');
                text_2 = createText(text_2_value);
                text_4 = createText('\r\n      ');
                div_3 = createElement('div');
                div_4 = createElement('div');
                text_5 = createText(text_5_value);
                text_6 = createText('\r\n        ');
                h2 = createElement('h2');
                a = createElement('a');
                text_7 = createText(text_7_value);
                text_8 = createText('\r\n        ');
                div_5 = createElement('div');
                text_9 = createText(text_9_value);
                this.h();
            },

            h: function hydrate() {
                div_1.className = 'db-month';
                div_2.className = 'db-date';
                div.className = 'date-block media-object-section';
                setAttribute(div, 'aria-hidden', 'true');
                div_4.className = 'date';
                a.href = a_href_value = item.url;
                h2.className = 'h6 title';
                div_5.className = 'body';
                div_3.className = 'content media-object-section';
                li.className = 'media-object';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(div, li);
                appendNode(div_1, div);
                appendNode(text, div_1);
                appendNode(text_1, div);
                appendNode(div_2, div);
                appendNode(text_2, div_2);
                appendNode(text_4, li);
                appendNode(div_3, li);
                appendNode(div_4, div_3);
                appendNode(text_5, div_4);
                appendNode(text_6, div_3);
                appendNode(h2, div_3);
                appendNode(a, h2);
                appendNode(text_7, a);
                appendNode(text_8, div_3);
                appendNode(div_5, div_3);
                appendNode(text_9, div_5);
            },

            p: function update(
                changed,
                state,
                paginatedItems_1,
                item,
                item_index
            ) {
                if (
                    changed.paginatedItems &&
                    text_value !== (text_value = item.month)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.paginatedItems &&
                    text_2_value !== (text_2_value = item.date)
                ) {
                    text_2.data = text_2_value;
                }

                if (
                    changed.paginatedItems &&
                    text_5_value !== (text_5_value = item.timestampFormatted)
                ) {
                    text_5.data = text_5_value;
                }

                if (
                    changed.paginatedItems &&
                    text_7_value !== (text_7_value = item.title)
                ) {
                    text_7.data = text_7_value;
                }

                if (
                    changed.paginatedItems &&
                    a_href_value !== (a_href_value = item.url)
                ) {
                    a.href = a_href_value;
                }

                if (
                    changed.paginatedItems &&
                    text_9_value !== (text_9_value = item.summary)
                ) {
                    text_9.data = text_9_value;
                }
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (73:19) {{#if paginatedItems.length}}
    function create_if_block_1$3(state, component) {
        var each_anchor;

        var paginatedItems_1 = state.paginatedItems;

        var each_blocks = [];

        for (var i = 0; i < paginatedItems_1.length; i += 1) {
            each_blocks[i] = create_each_block$3(
                state,
                paginatedItems_1,
                paginatedItems_1[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                each_anchor = createComment();
            },

            m: function mount(target, anchor) {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(target, anchor);
                }

                insertNode(each_anchor, target, anchor);
            },

            p: function update(changed, state) {
                var paginatedItems_1 = state.paginatedItems;

                if (changed.paginatedItems) {
                    for (var i = 0; i < paginatedItems_1.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                paginatedItems_1,
                                paginatedItems_1[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block$3(
                                state,
                                paginatedItems_1,
                                paginatedItems_1[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(
                                each_anchor.parentNode,
                                each_anchor
                            );
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = paginatedItems_1.length;
                }
            },

            u: function unmount() {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                detachNode(each_anchor);
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);
            },
        };
    }

    // (84:18) {{else}}
    function create_if_block_2$2(state, component) {
        var loader = new Loader({
            root: component.root,
        });

        return {
            c: function create() {
                loader._fragment.c();
            },

            m: function mount(target, anchor) {
                loader._mount(target, anchor);
            },

            p: noop,

            u: function unmount() {
                loader._unmount();
            },

            d: function destroy$$1() {
                loader.destroy(false);
            },
        };
    }

    // (88:27) {{#if page <= 1}}
    function create_if_block_4$1(state, component) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                li.innerHTML = '<span class="show-for-sr">Previous page</span>';
                this.h();
            },

            h: function hydrate() {
                li.className = 'pagination-previous disabled';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (89:98) {{else}}
    function create_if_block_5$1(state, component) {
        var li, a;

        function click_handler(event) {
            component.navigate(event, 'previous');
        }

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                a.innerHTML = '<span class="show-for-sr">Previous page</span>';
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(a, 'aria-label', 'Previous page');
                addListener(a, 'click', click_handler);
                li.className = 'pagination-previous';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler);
            },
        };
    }

    // (90:178) {{#each navItems as item}}
    function create_each_block_1$2(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var if_block_anchor;

        var current_block_type = select_block_type_2$1(
            state,
            navItems_2,
            item,
            item_index
        );
        var if_block = current_block_type(
            state,
            navItems_2,
            item,
            item_index,
            component
        );

        return {
            c: function create() {
                if_block.c();
                if_block_anchor = createComment();
            },

            m: function mount(target, anchor) {
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type_2$1(
                            state,
                            navItems_2,
                            item,
                            item_index
                        )) &&
                    if_block
                ) {
                    if_block.p(changed, state, navItems_2, item, item_index);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(
                        state,
                        navItems_2,
                        item,
                        item_index,
                        component
                    );
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                if_block.d();
            },
        };
    }

    // (90:204) {{#if item.on}}
    function create_if_block_6$1(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var li,
            span,
            text_1_value = item.value,
            text_1;

        return {
            c: function create() {
                li = createElement('li');
                span = createElement('span');
                span.textContent = "You're on page ";
                text_1 = createText(text_1_value);
                this.h();
            },

            h: function hydrate() {
                span.className = 'show-for-sr';
                li.className = 'current';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(span, li);
                appendNode(text_1, li);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    changed.navItems &&
                    text_1_value !== (text_1_value = item.value)
                ) {
                    text_1.data = text_1_value;
                }
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (91:112)
    function create_if_block_7$1(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                this.h();
            },

            h: function hydrate() {
                li.className = 'ellipsis';
                setAttribute(li, 'aria-hidden', 'true');
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            p: noop,

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (92:51) {{else}}
    function create_if_block_8$1(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var li,
            a,
            text_value = item.value,
            text,
            a_aria_label_value;

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                text = createText(text_value);
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(
                    a,
                    'aria-label',
                    (a_aria_label_value = 'Page ' + item.value)
                );
                addListener(a, 'click', click_handler$1);

                a._svelte = {
                    component: component,
                    navItems_2: navItems_2,
                    item_index: item_index,
                };
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
                appendNode(text, a);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    changed.navItems &&
                    text_value !== (text_value = item.value)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.navItems &&
                    a_aria_label_value !==
                        (a_aria_label_value = 'Page ' + item.value)
                ) {
                    setAttribute(a, 'aria-label', a_aria_label_value);
                }

                a._svelte.navItems_2 = navItems_2;
                a._svelte.item_index = item_index;
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler$1);
            },
        };
    }

    // (93:133) {{#if page >= navRange.length}}
    function create_if_block_9$1(state, component) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                li.innerHTML = '<span class="show-for-sr">Next page</span>';
                this.h();
            },

            h: function hydrate() {
                li.className = 'pagination-next disabled';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (94:90) {{else}}
    function create_if_block_10$1(state, component) {
        var li, a;

        function click_handler_1(event) {
            component.navigate(event, 'next');
        }

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                a.innerHTML = '<span class="show-for-sr">Next page</span>';
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(a, 'aria-label', 'Next page');
                addListener(a, 'click', click_handler_1);
                li.className = 'pagination-next';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler_1);
            },
        };
    }

    // (86:7) {{#if navItems.length > 1 && paginatedItems.length}}
    function create_if_block_3$2(state, component) {
        var nav, ul, if_block_anchor, each_anchor;

        var current_block_type = select_block_type_1$2(state);
        var if_block = current_block_type(state, component);

        var navItems_2 = state.navItems;

        var each_blocks = [];

        for (var i = 0; i < navItems_2.length; i += 1) {
            each_blocks[i] = create_each_block_1$2(
                state,
                navItems_2,
                navItems_2[i],
                i,
                component
            );
        }

        var current_block_type_1 = select_block_type_3$1(state);
        var if_block_1 = current_block_type_1(state, component);

        return {
            c: function create() {
                nav = createElement('nav');
                ul = createElement('ul');
                if_block.c();
                if_block_anchor = createComment();

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                each_anchor = createComment();
                if_block_1.c();
                this.h();
            },

            h: function hydrate() {
                ul.className = 'pagination';
                nav.className = 'list-navigation';
                setAttribute(nav, 'role', 'navigation');
                setAttribute(nav, 'aria-label', 'Events list pagination');
            },

            m: function mount(target, anchor) {
                insertNode(nav, target, anchor);
                appendNode(ul, nav);
                if_block.m(ul, null);
                appendNode(if_block_anchor, ul);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(ul, null);
                }

                appendNode(each_anchor, ul);
                if_block_1.m(ul, null);
            },

            p: function update(changed, state) {
                if (
                    current_block_type !==
                    (current_block_type = select_block_type_1$2(state))
                ) {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(ul, if_block_anchor);
                }

                var navItems_2 = state.navItems;

                if (changed.navItems) {
                    for (var i = 0; i < navItems_2.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                navItems_2,
                                navItems_2[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block_1$2(
                                state,
                                navItems_2,
                                navItems_2[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(ul, each_anchor);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = navItems_2.length;
                }

                if (
                    current_block_type_1 !==
                    (current_block_type_1 = select_block_type_3$1(state))
                ) {
                    if_block_1.u();
                    if_block_1.d();
                    if_block_1 = current_block_type_1(state, component);
                    if_block_1.c();
                    if_block_1.m(ul, null);
                }
            },

            u: function unmount() {
                detachNode(nav);
                if_block.u();

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                if_block_1.u();
            },

            d: function destroy$$1() {
                if_block.d();

                destroyEach(each_blocks);

                if_block_1.d();
            },
        };
    }

    function select_block_type$3(state) {
        if (state.paginatedItems.length) {
            return create_if_block_1$3;
        }
        return create_if_block_2$2;
    }

    function select_block_type_1$2(state) {
        if (state.page <= 1) {
            return create_if_block_4$1;
        }
        return create_if_block_5$1;
    }

    function click_handler$1(event) {
        var component = this._svelte.component;
        var navItems_2 = this._svelte.navItems_2,
            item_index = this._svelte.item_index,
            item = navItems_2[item_index];
        component.navigate(event, item.value);
    }

    function select_block_type_2$1(state, navItems_2, item, item_index) {
        if (item.on) {
            return create_if_block_6$1;
        }
        if (item.etc) {
            return create_if_block_7$1;
        }
        return create_if_block_8$1;
    }

    function select_block_type_3$1(state) {
        if (state.page >= state.navRange.length) {
            return create_if_block_9$1;
        }
        return create_if_block_10$1;
    }

    function EventsList(options) {
        init(this, options);
        this.refs = {};
        this._state = assign(data$2(), options.data);
        this._state.yPos = window.scrollY;
        this._recompute(
            {
                items: 1,
                tag: 1,
                filteredItems: 1,
                page: 1,
                pagesize: 1,
                navRange: 1,
            },
            this._state
        );

        var _oncreate = oncreate$4.bind(this);

        if (!options.root) {
            this._oncreate = [_oncreate];
            this._beforecreate = [];
            this._aftercreate = [];
        } else {
            this.root._oncreate.push(_oncreate);
        }

        this._fragment = create_main_fragment$4(this._state, this);

        if (options.target) {
            this._fragment.c();
            this._fragment.m(options.target, options.anchor || null);

            this._lock = true;
            callAll(this._beforecreate);
            callAll(this._oncreate);
            callAll(this._aftercreate);
            this._lock = false;
        }
    }

    assign(EventsList.prototype, methods$2, proto);

    EventsList.prototype._recompute = function _recompute(changed, state) {
        if (changed.items || changed.tag) {
            if (
                differs(
                    state.filteredItems,
                    (state.filteredItems = filteredItems$1(
                        state.items,
                        state.tag
                    ))
                )
            ) {
                changed.filteredItems = true;
            }
        }

        if (changed.filteredItems || changed.page || changed.pagesize) {
            if (
                differs(
                    state.paginatedItems,
                    (state.paginatedItems = paginatedItems$1(
                        state.filteredItems,
                        state.page,
                        state.pagesize
                    ))
                )
            ) {
                changed.paginatedItems = true;
            }
        }

        if (changed.filteredItems || changed.pagesize) {
            if (
                differs(
                    state.navRange,
                    (state.navRange = navRange$1(
                        state.filteredItems,
                        state.pagesize
                    ))
                )
            ) {
                changed.navRange = true;
            }
        }

        if (changed.filteredItems || changed.page || changed.navRange) {
            if (
                differs(
                    state.navItems,
                    (state.navItems = navItems_1$1(
                        state.filteredItems,
                        state.page,
                        state.navRange
                    ))
                )
            ) {
                changed.navItems = true;
            }
        }
    };

    /* client/source/app/components/Directory.html generated by Svelte v1.50.0 */
    function loaded$2(items) {
        return !!items;
    }

    function pagesize(windowWidth) {
        if (windowWidth < 700) {
            return 8;
        } else if (windowWidth < 1024) {
            return 6;
        }
        return 8;
    }

    function filteredItems$2(items, query, departmentFilter) {
        // filter and sort
        if (query && query.trim()) {
            var fuse = new Fuse(items.slice(), {
                // shouldSort: true,
                keys: ['name'],
                threshold: 0.5,
            });
            items = fuse.search(query);
        }
        if (departmentFilter !== 'all') {
            items = _.filter(items, { departmentKey: departmentFilter });
        }
        return _.sortBy(items, ['last', 'first']);
    }

    function paginatedItems$2(filteredItems, page, pagesize) {
        var start = (page - 1) * pagesize;
        filteredItems = filteredItems.slice(start, start + pagesize);
        return filteredItems;
    }

    function navRange$2(filteredItems, pagesize) {
        return _.range(1, filteredItems.length / pagesize + 1);
    }

    function navItems_1$2(filteredItems, page, navRange) {
        return navItems(filteredItems, page, navRange);
    }

    function data$3() {
        return {
            preQuery: '',
        };
    }

    var methods$3 = {
        tween: tween,
        submitFilters: function submitFilters(event, preQuery) {
            event.preventDefault();
            this.set({ query: preQuery });
            this.getOptionSize();
        },
        navigate: function navigate$$1(event, direction) {
            event.preventDefault();
            var page = this.get('page');
            if (direction === 'previous') {
                --page;
            } else if (direction === 'next') {
                ++page;
            } else {
                page = direction;
            }
            this.set({ page: page });

            // scroll up
            if (this.get('windowWidth') < 700) {
                this.set({ yPosMirror: this.get('yPos') });
                this.tween(
                    'yPosMirror',
                    getElementOffset(this.refs.list) - 100,
                    {
                        duration: 1000,
                        easing: cubicOut,
                    }
                );
            }
            // focus first item
            setFocus(this.refs.list);
        },

        checkPagination: function checkPagination(navRange, page) {
            if (navRange.length < parseInt(page)) {
                this.set({ page: navRange.length });
            }
        },

        checkState: checkState,

        getOptionSize: function getOptionSize() {
            var this$1 = this;

            this.set({
                optionText:
                    this.refs.select.querySelector('option:checked')
                        .textContent,
            });
            // wait for DOM
            setTimeout(function () {
                this$1.set({
                    optionTextSize:
                        this$1.refs.optionText.getBoundingClientRect().width,
                });
            }, 0);
        },
    };

    function oncreate$5() {
        var this$1 = this;

        this.getOptionSize();

        // just some simple state management
        this.observe('departmentFilter', function (departmentFilter) {
            return this$1.checkState(
                'departmentFilter',
                departmentFilter,
                'all'
            );
        });
        this.observe('query', function (query) {
            return this$1.checkState('query', query, '');
        });
        this.observe('page', function (page) {
            return this$1.checkState('page', page, 1);
        });

        // one time fetch
        fetch(this.get('url'))
            .then(function (response) {
                return response.json();
            })
            .then(function (json) {
                this$1.set({
                    items: json.directory,
                    departments: json.departments,
                });
            });
        // TODO: handle errors gracefully?
        // .catch(ex => console.log('parsing failed', ex))

        // I hate this indirection, but it works...
        this.observe(
            'yPosMirror',
            function (yPos) {
                this$1.set({ yPos: yPos });
            },
            { init: false }
        );
    }

    function create_main_fragment$5(state, component) {
        var window_updating = false,
            div,
            form,
            div_1,
            div_2,
            div_3,
            text,
            text_2,
            label,
            text_3,
            span,
            select,
            option,
            text_4,
            select_updating = false,
            text_6,
            div_4,
            label_1,
            div_5,
            text_8,
            input,
            input_updating = false,
            text_9,
            button,
            text_15,
            div_6,
            div_7,
            text_16;

        function onwindowresize(event) {
            var state = component.get();
            component.checkPagination(state.navRange, state.page);
        }
        window.addEventListener('resize', onwindowresize);

        function onwindowscroll(event) {
            window_updating = true;

            component.set({
                yPos: this.scrollY,
            });
            window_updating = false;
        }
        window.addEventListener('scroll', onwindowscroll);

        function onwindowresize_1(event) {
            component.set({
                windowWidth: this.innerWidth,
            });
        }
        window.addEventListener('resize', onwindowresize_1);

        component.observe('yPos', function (y) {
            if (window_updating) {
                return;
            }
            window.scrollTo(window.scrollX, y);
        });

        var if_block = state.loaded && create_if_block$4(state, component);

        function select_change_handler() {
            select_updating = true;
            component.set({ departmentFilter: selectValue(select) });
            select_updating = false;
        }

        function change_handler(event) {
            component.getOptionSize();
        }

        function input_input_handler() {
            input_updating = true;
            component.set({ preQuery: input.value });
            input_updating = false;
        }

        function submit_handler(event) {
            var state = component.get();
            component.submitFilters(event, state.preQuery);
        }

        var current_block_type = select_block_type$4(state);
        var if_block_1 = current_block_type(state, component);

        var if_block_2 =
            state.navItems.length > 1 &&
            state.paginatedItems.length &&
            create_if_block_3$3(state, component);

        return {
            c: function create() {
                div = createElement('div');
                form = createElement('form');
                div_1 = createElement('div');
                div_2 = createElement('div');
                div_3 = createElement('div');
                text = createText(state.optionText);
                text_2 = createText('\r\n      ');
                label = createElement('label');
                text_3 = createText('Department');
                span = createElement('span');
                select = createElement('select');
                option = createElement('option');
                text_4 = createText('All');
                if (if_block) {
                    if_block.c();
                }
                text_6 = createText('\r\n    ');
                div_4 = createElement('div');
                label_1 = createElement('label');
                div_5 = createElement('div');
                div_5.textContent = 'Search Directory:';
                text_8 = createText('\r\n        ');
                input = createElement('input');
                text_9 = createText('\r\n        ');
                button = createElement('button');
                button.innerHTML = '<span class="ghost">Search</span>';
                text_15 = createText('\r\n');
                div_6 = createElement('div');
                div_7 = createElement('div');
                if_block_1.c();
                text_16 = createText('\r\n  ');
                if (if_block_2) {
                    if_block_2.c();
                }
                this.h();
            },

            h: function hydrate() {
                div_3.className = 'option-text';
                div_2.className = 'option-text-wrap';
                option.__value = 'all';
                option.value = option.__value;
                addListener(select, 'change', select_change_handler);
                if (!('departmentFilter' in state)) {
                    component.root._beforecreate.push(select_change_handler);
                }
                addListener(select, 'change', change_handler);
                span.className = 'select-box';
                setStyle(
                    span,
                    'width',
                    '' + (state.optionTextSize + 25) + 'px'
                );
                div_1.className = 'group filter-group';
                div_5.className = 'ghost';
                addListener(input, 'input', input_input_handler);
                input.type = 'text';
                button.type = 'submit';
                label_1.className = 'input-box';
                div_4.className = 'group query-group';
                form.className = 'directory-filters';
                addListener(form, 'submit', submit_handler);
                div.className = 'listing-toolbar fullwidth';
                div_7.className = 'items grid-x grid-margin-x';
                div_6.className = 'directory block';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(form, div);
                appendNode(div_1, form);
                appendNode(div_2, div_1);
                appendNode(div_3, div_2);
                appendNode(text, div_3);
                component.refs.optionText = div_3;
                appendNode(text_2, div_1);
                appendNode(label, div_1);
                appendNode(text_3, label);
                appendNode(span, label);
                appendNode(select, span);
                appendNode(option, select);
                appendNode(text_4, option);
                if (if_block) {
                    if_block.m(select, null);
                }
                component.refs.select = select;

                selectOption(select, state.departmentFilter);

                appendNode(text_6, form);
                appendNode(div_4, form);
                appendNode(label_1, div_4);
                appendNode(div_5, label_1);
                appendNode(text_8, label_1);
                appendNode(input, label_1);

                input.value = state.preQuery;

                appendNode(text_9, label_1);
                appendNode(button, label_1);
                insertNode(text_15, target, anchor);
                insertNode(div_6, target, anchor);
                appendNode(div_7, div_6);
                if_block_1.m(div_7, null);
                appendNode(text_16, div_7);
                if (if_block_2) {
                    if_block_2.m(div_6, null);
                }
                component.refs.list = div_6;
            },

            p: function update(changed, state) {
                if (changed.optionText) {
                    text.data = state.optionText;
                }

                if (state.loaded) {
                    if (if_block) {
                        if_block.p(changed, state);
                    } else {
                        if_block = create_if_block$4(state, component);
                        if_block.c();
                        if_block.m(select, null);
                    }
                } else if (if_block) {
                    if_block.u();
                    if_block.d();
                    if_block = null;
                }

                if (!select_updating) {
                    selectOption(select, state.departmentFilter);
                }
                if (changed.optionTextSize) {
                    setStyle(
                        span,
                        'width',
                        '' + (state.optionTextSize + 25) + 'px'
                    );
                }

                if (!input_updating) {
                    input.value = state.preQuery;
                }

                if (
                    current_block_type ===
                        (current_block_type = select_block_type$4(state)) &&
                    if_block_1
                ) {
                    if_block_1.p(changed, state);
                } else {
                    if_block_1.u();
                    if_block_1.d();
                    if_block_1 = current_block_type(state, component);
                    if_block_1.c();
                    if_block_1.m(div_7, text_16);
                }

                if (state.navItems.length > 1 && state.paginatedItems.length) {
                    if (if_block_2) {
                        if_block_2.p(changed, state);
                    } else {
                        if_block_2 = create_if_block_3$3(state, component);
                        if_block_2.c();
                        if_block_2.m(div_6, null);
                    }
                } else if (if_block_2) {
                    if_block_2.u();
                    if_block_2.d();
                    if_block_2 = null;
                }
            },

            u: function unmount() {
                detachNode(div);
                if (if_block) {
                    if_block.u();
                }
                detachNode(text_15);
                detachNode(div_6);
                if_block_1.u();
                if (if_block_2) {
                    if_block_2.u();
                }
            },

            d: function destroy$$1() {
                window.removeEventListener('resize', onwindowresize);

                window.removeEventListener('scroll', onwindowscroll);

                window.removeEventListener('resize', onwindowresize_1);

                if (component.refs.optionText === div_3) {
                    component.refs.optionText = null;
                }
                if (if_block) {
                    if_block.d();
                }
                removeListener(select, 'change', select_change_handler);
                removeListener(select, 'change', change_handler);
                if (component.refs.select === select) {
                    component.refs.select = null;
                }
                removeListener(input, 'input', input_input_handler);
                removeListener(form, 'submit', submit_handler);
                if_block_1.d();
                if (if_block_2) {
                    if_block_2.d();
                }
                if (component.refs.list === div_6) {
                    component.refs.list = null;
                }
            },
        };
    }

    // (141:58) {{#each departments as dept}}
    function create_each_block$4(
        state,
        departments,
        dept,
        dept_index,
        component
    ) {
        var option,
            text_value = dept.value,
            text,
            option_value_value;

        return {
            c: function create() {
                option = createElement('option');
                text = createText(text_value);
                this.h();
            },

            h: function hydrate() {
                option.__value = option_value_value = dept.key;
                option.value = option.__value;
            },

            m: function mount(target, anchor) {
                insertNode(option, target, anchor);
                appendNode(text, option);
            },

            p: function update(changed, state, departments, dept, dept_index) {
                if (
                    changed.departments &&
                    text_value !== (text_value = dept.value)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.departments &&
                    option_value_value !== (option_value_value = dept.key)
                ) {
                    option.__value = option_value_value;
                }

                option.value = option.__value;
            },

            u: function unmount() {
                detachNode(option);
            },

            d: noop,
        };
    }

    // (141:44) {{#if loaded}}
    function create_if_block$4(state, component) {
        var each_anchor;

        var departments = state.departments;

        var each_blocks = [];

        for (var i = 0; i < departments.length; i += 1) {
            each_blocks[i] = create_each_block$4(
                state,
                departments,
                departments[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                each_anchor = createComment();
            },

            m: function mount(target, anchor) {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(target, anchor);
                }

                insertNode(each_anchor, target, anchor);
            },

            p: function update(changed, state) {
                var departments = state.departments;

                if (changed.departments) {
                    for (var i = 0; i < departments.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                departments,
                                departments[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block$4(
                                state,
                                departments,
                                departments[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(
                                each_anchor.parentNode,
                                each_anchor
                            );
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = departments.length;
                }
            },

            u: function unmount() {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                detachNode(each_anchor);
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);
            },
        };
    }

    // (155:71) {{#each paginatedItems as item}}
    function create_each_block_1$3(
        state,
        paginatedItems_1,
        item,
        item_index,
        component
    ) {
        var div,
            div_1,
            div_2,
            div_3,
            img,
            img_src_value,
            img_alt_value,
            text_1,
            div_4,
            h2,
            a,
            text_2_value = item.name,
            text_2,
            a_href_value,
            text_3,
            div_5,
            text_4_value = item.jobTitle,
            text_4,
            text_5,
            div_6,
            text_6_value = item.department,
            text_6;

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');
                div_2 = createElement('div');
                div_3 = createElement('div');
                img = createElement('img');
                text_1 = createText('\r\n        ');
                div_4 = createElement('div');
                h2 = createElement('h2');
                a = createElement('a');
                text_2 = createText(text_2_value);
                text_3 = createText('\r\n          ');
                div_5 = createElement('div');
                text_4 = createText(text_4_value);
                text_5 = createText('\r\n          ');
                div_6 = createElement('div');
                text_6 = createText(text_6_value);
                this.h();
            },

            h: function hydrate() {
                img.src = img_src_value = item.image;
                img.alt = img_alt_value = item.imageAlt;
                div_3.className = 'bg';
                setStyle(div_3, 'background-image', 'url(' + item.image + ')');
                div_2.className = 'card-divider';
                a.href = a_href_value = item.url;
                h2.className = 'title';
                div_5.className = 'job-title';
                div_6.className = 'department';
                div_4.className = 'card-section';
                div_1.className = 'card';
                div.className = 'item cell small-12 medium-4 large-3';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                appendNode(div_2, div_1);
                appendNode(div_3, div_2);
                appendNode(img, div_3);
                appendNode(text_1, div_1);
                appendNode(div_4, div_1);
                appendNode(h2, div_4);
                appendNode(a, h2);
                appendNode(text_2, a);
                appendNode(text_3, div_4);
                appendNode(div_5, div_4);
                appendNode(text_4, div_5);
                appendNode(text_5, div_4);
                appendNode(div_6, div_4);
                appendNode(text_6, div_6);
            },

            p: function update(
                changed,
                state,
                paginatedItems_1,
                item,
                item_index
            ) {
                if (
                    changed.paginatedItems &&
                    img_src_value !== (img_src_value = item.image)
                ) {
                    img.src = img_src_value;
                }

                if (
                    changed.paginatedItems &&
                    img_alt_value !== (img_alt_value = item.imageAlt)
                ) {
                    img.alt = img_alt_value;
                }

                if (changed.paginatedItems) {
                    setStyle(
                        div_3,
                        'background-image',
                        'url(' + item.image + ')'
                    );
                }

                if (
                    changed.paginatedItems &&
                    text_2_value !== (text_2_value = item.name)
                ) {
                    text_2.data = text_2_value;
                }

                if (
                    changed.paginatedItems &&
                    a_href_value !== (a_href_value = item.url)
                ) {
                    a.href = a_href_value;
                }

                if (
                    changed.paginatedItems &&
                    text_4_value !== (text_4_value = item.jobTitle)
                ) {
                    text_4.data = text_4_value;
                }

                if (
                    changed.paginatedItems &&
                    text_6_value !== (text_6_value = item.department)
                ) {
                    text_6.data = text_6_value;
                }
            },

            u: function unmount() {
                detachNode(div);
            },

            d: noop,
        };
    }

    // (155:42) {{#if paginatedItems.length}}
    function create_if_block_1$4(state, component) {
        var each_anchor;

        var paginatedItems_1 = state.paginatedItems;

        var each_blocks = [];

        for (var i = 0; i < paginatedItems_1.length; i += 1) {
            each_blocks[i] = create_each_block_1$3(
                state,
                paginatedItems_1,
                paginatedItems_1[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                each_anchor = createComment();
            },

            m: function mount(target, anchor) {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(target, anchor);
                }

                insertNode(each_anchor, target, anchor);
            },

            p: function update(changed, state) {
                var paginatedItems_1 = state.paginatedItems;

                if (changed.paginatedItems) {
                    for (var i = 0; i < paginatedItems_1.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                paginatedItems_1,
                                paginatedItems_1[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block_1$3(
                                state,
                                paginatedItems_1,
                                paginatedItems_1[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(
                                each_anchor.parentNode,
                                each_anchor
                            );
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = paginatedItems_1.length;
                }
            },

            u: function unmount() {
                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                detachNode(each_anchor);
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);
            },
        };
    }

    // (167:19) {{else}}
    function create_if_block_2$3(state, component) {
        var loader = new Loader({
            root: component.root,
        });

        return {
            c: function create() {
                loader._fragment.c();
            },

            m: function mount(target, anchor) {
                loader._mount(target, anchor);
            },

            p: noop,

            u: function unmount() {
                loader._unmount();
            },

            d: function destroy$$1() {
                loader.destroy(false);
            },
        };
    }

    // (171:27) {{#if page <= 1}}
    function create_if_block_4$2(state, component) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                li.innerHTML = '<span class="show-for-sr">Previous page</span>';
                this.h();
            },

            h: function hydrate() {
                li.className = 'pagination-previous disabled';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (172:98) {{else}}
    function create_if_block_5$2(state, component) {
        var li, a;

        function click_handler(event) {
            component.navigate(event, 'previous');
        }

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                a.innerHTML = '<span class="show-for-sr">Previous page</span>';
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(a, 'aria-label', 'Previous page');
                addListener(a, 'click', click_handler);
                li.className = 'pagination-previous';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler);
            },
        };
    }

    // (173:178) {{#each navItems as item}}
    function create_each_block_2$1(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var if_block_anchor;

        var current_block_type = select_block_type_2$2(
            state,
            navItems_2,
            item,
            item_index
        );
        var if_block = current_block_type(
            state,
            navItems_2,
            item,
            item_index,
            component
        );

        return {
            c: function create() {
                if_block.c();
                if_block_anchor = createComment();
            },

            m: function mount(target, anchor) {
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type_2$2(
                            state,
                            navItems_2,
                            item,
                            item_index
                        )) &&
                    if_block
                ) {
                    if_block.p(changed, state, navItems_2, item, item_index);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(
                        state,
                        navItems_2,
                        item,
                        item_index,
                        component
                    );
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                if_block.d();
            },
        };
    }

    // (173:204) {{#if item.on}}
    function create_if_block_6$2(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var li,
            span,
            text_1_value = item.value,
            text_1;

        return {
            c: function create() {
                li = createElement('li');
                span = createElement('span');
                span.textContent = "You're on page ";
                text_1 = createText(text_1_value);
                this.h();
            },

            h: function hydrate() {
                span.className = 'show-for-sr';
                li.className = 'current';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(span, li);
                appendNode(text_1, li);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    changed.navItems &&
                    text_1_value !== (text_1_value = item.value)
                ) {
                    text_1.data = text_1_value;
                }
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (174:112)
    function create_if_block_7$2(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                this.h();
            },

            h: function hydrate() {
                li.className = 'ellipsis';
                setAttribute(li, 'aria-hidden', 'true');
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            p: noop,

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (175:51) {{else}}
    function create_if_block_8$2(
        state,
        navItems_2,
        item,
        item_index,
        component
    ) {
        var li,
            a,
            text_value = item.value,
            text,
            a_aria_label_value;

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                text = createText(text_value);
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(
                    a,
                    'aria-label',
                    (a_aria_label_value = 'Page ' + item.value)
                );
                addListener(a, 'click', click_handler$2);

                a._svelte = {
                    component: component,
                    navItems_2: navItems_2,
                    item_index: item_index,
                };
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
                appendNode(text, a);
            },

            p: function update(changed, state, navItems_2, item, item_index) {
                if (
                    changed.navItems &&
                    text_value !== (text_value = item.value)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.navItems &&
                    a_aria_label_value !==
                        (a_aria_label_value = 'Page ' + item.value)
                ) {
                    setAttribute(a, 'aria-label', a_aria_label_value);
                }

                a._svelte.navItems_2 = navItems_2;
                a._svelte.item_index = item_index;
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler$2);
            },
        };
    }

    // (176:133) {{#if page >= navRange.length}}
    function create_if_block_9$2(state, component) {
        var li;

        return {
            c: function create() {
                li = createElement('li');
                li.innerHTML = '<span class="show-for-sr">Next page</span>';
                this.h();
            },

            h: function hydrate() {
                li.className = 'pagination-next disabled';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: noop,
        };
    }

    // (177:90) {{else}}
    function create_if_block_10$2(state, component) {
        var li, a;

        function click_handler_1(event) {
            component.navigate(event, 'next');
        }

        return {
            c: function create() {
                li = createElement('li');
                a = createElement('a');
                a.innerHTML = '<span class="show-for-sr">Next page</span>';
                this.h();
            },

            h: function hydrate() {
                a.href = '/';
                setAttribute(a, 'aria-label', 'Next page');
                addListener(a, 'click', click_handler_1);
                li.className = 'pagination-next';
            },

            m: function mount(target, anchor) {
                insertNode(li, target, anchor);
                appendNode(a, li);
            },

            u: function unmount() {
                detachNode(li);
            },

            d: function destroy$$1() {
                removeListener(a, 'click', click_handler_1);
            },
        };
    }

    // (169:8) {{#if navItems.length > 1 && paginatedItems.length}}
    function create_if_block_3$3(state, component) {
        var nav, ul, if_block_anchor, each_anchor;

        var current_block_type = select_block_type_1$3(state);
        var if_block = current_block_type(state, component);

        var navItems_2 = state.navItems;

        var each_blocks = [];

        for (var i = 0; i < navItems_2.length; i += 1) {
            each_blocks[i] = create_each_block_2$1(
                state,
                navItems_2,
                navItems_2[i],
                i,
                component
            );
        }

        var current_block_type_1 = select_block_type_3$2(state);
        var if_block_1 = current_block_type_1(state, component);

        return {
            c: function create() {
                nav = createElement('nav');
                ul = createElement('ul');
                if_block.c();
                if_block_anchor = createComment();

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                each_anchor = createComment();
                if_block_1.c();
                this.h();
            },

            h: function hydrate() {
                ul.className = 'pagination';
                nav.className = 'list-navigation';
                setAttribute(nav, 'role', 'navigation');
                setAttribute(nav, 'aria-label', 'Directory list pagination');
            },

            m: function mount(target, anchor) {
                insertNode(nav, target, anchor);
                appendNode(ul, nav);
                if_block.m(ul, null);
                appendNode(if_block_anchor, ul);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(ul, null);
                }

                appendNode(each_anchor, ul);
                if_block_1.m(ul, null);
            },

            p: function update(changed, state) {
                if (
                    current_block_type !==
                    (current_block_type = select_block_type_1$3(state))
                ) {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(ul, if_block_anchor);
                }

                var navItems_2 = state.navItems;

                if (changed.navItems) {
                    for (var i = 0; i < navItems_2.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                navItems_2,
                                navItems_2[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block_2$1(
                                state,
                                navItems_2,
                                navItems_2[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(ul, each_anchor);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = navItems_2.length;
                }

                if (
                    current_block_type_1 !==
                    (current_block_type_1 = select_block_type_3$2(state))
                ) {
                    if_block_1.u();
                    if_block_1.d();
                    if_block_1 = current_block_type_1(state, component);
                    if_block_1.c();
                    if_block_1.m(ul, null);
                }
            },

            u: function unmount() {
                detachNode(nav);
                if_block.u();

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                if_block_1.u();
            },

            d: function destroy$$1() {
                if_block.d();

                destroyEach(each_blocks);

                if_block_1.d();
            },
        };
    }

    function select_block_type$4(state) {
        if (state.paginatedItems.length) {
            return create_if_block_1$4;
        }
        return create_if_block_2$3;
    }

    function select_block_type_1$3(state) {
        if (state.page <= 1) {
            return create_if_block_4$2;
        }
        return create_if_block_5$2;
    }

    function click_handler$2(event) {
        var component = this._svelte.component;
        var navItems_2 = this._svelte.navItems_2,
            item_index = this._svelte.item_index,
            item = navItems_2[item_index];
        component.navigate(event, item.value);
    }

    function select_block_type_2$2(state, navItems_2, item, item_index) {
        if (item.on) {
            return create_if_block_6$2;
        }
        if (item.etc) {
            return create_if_block_7$2;
        }
        return create_if_block_8$2;
    }

    function select_block_type_3$2(state) {
        if (state.page >= state.navRange.length) {
            return create_if_block_9$2;
        }
        return create_if_block_10$2;
    }

    function Directory(options) {
        init(this, options);
        this.refs = {};
        this._state = assign(data$3(), options.data);
        this._state.yPos = window.scrollY;
        this._state.windowWidth = window.innerWidth;
        this._recompute(
            {
                items: 1,
                windowWidth: 1,
                query: 1,
                departmentFilter: 1,
                filteredItems: 1,
                page: 1,
                pagesize: 1,
                navRange: 1,
            },
            this._state
        );

        var _oncreate = oncreate$5.bind(this);

        if (!options.root) {
            this._oncreate = [_oncreate];
            this._beforecreate = [];
            this._aftercreate = [];
        } else {
            this.root._oncreate.push(_oncreate);
        }

        this._fragment = create_main_fragment$5(this._state, this);

        if (options.target) {
            this._fragment.c();
            this._fragment.m(options.target, options.anchor || null);

            this._lock = true;
            callAll(this._beforecreate);
            callAll(this._oncreate);
            callAll(this._aftercreate);
            this._lock = false;
        }
    }

    assign(Directory.prototype, methods$3, proto);

    Directory.prototype._recompute = function _recompute(changed, state) {
        if (changed.items) {
            if (differs(state.loaded, (state.loaded = loaded$2(state.items)))) {
                changed.loaded = true;
            }
        }

        if (changed.windowWidth) {
            if (
                differs(
                    state.pagesize,
                    (state.pagesize = pagesize(state.windowWidth))
                )
            ) {
                changed.pagesize = true;
            }
        }

        if (changed.items || changed.query || changed.departmentFilter) {
            if (
                differs(
                    state.filteredItems,
                    (state.filteredItems = filteredItems$2(
                        state.items,
                        state.query,
                        state.departmentFilter
                    ))
                )
            ) {
                changed.filteredItems = true;
            }
        }

        if (changed.filteredItems || changed.page || changed.pagesize) {
            if (
                differs(
                    state.paginatedItems,
                    (state.paginatedItems = paginatedItems$2(
                        state.filteredItems,
                        state.page,
                        state.pagesize
                    ))
                )
            ) {
                changed.paginatedItems = true;
            }
        }

        if (changed.filteredItems || changed.pagesize) {
            if (
                differs(
                    state.navRange,
                    (state.navRange = navRange$2(
                        state.filteredItems,
                        state.pagesize
                    ))
                )
            ) {
                changed.navRange = true;
            }
        }

        if (changed.filteredItems || changed.page || changed.navRange) {
            if (
                differs(
                    state.navItems,
                    (state.navItems = navItems_1$2(
                        state.filteredItems,
                        state.page,
                        state.navRange
                    ))
                )
            ) {
                changed.navItems = true;
            }
        }
    };

    /* client/source/app/components/ResponsiveCarousel.html generated by Svelte v1.50.0 */
    // import { tween } from 'svelte-extras'

    function loaded$3(items) {
        return !!items;
    }

    function isSmallScreen(windowWidth) {
        return windowWidth < 700 ? true : false;
    }

    function transitionStyle(isSmallScreen, windowWidth, selectedIndex) {
        if (isSmallScreen) {
            var itemWidth = windowWidth - 60 + 15;
            return 'transform:translateX(' + itemWidth * -selectedIndex + 'px)';
        }
        return '';
    }

    function data$4() {
        return {
            frozen: false,
        };
    }

    var methods$4 = {
        // tween,
        freezeTransitions: function freezeTransitions() {
            this.set({ frozen: true });
            this.debounceResizeEnd(this);
        },
        debounceResizeEnd: (function () {
            return _.debounce(function () {
                this.set({ frozen: false });
            }, 250);
        })(),
    };

    function oncreate$6() {
        var this$1 = this;

        // one time fetch
        fetch(this.get('url'))
            .then(function (response) {
                return response.json();
            })
            .then(function (json) {
                // console.log(json)
                this$1.set({
                    selectedIndex: 0,
                    items: json,
                });
            });
        // TODO: handle errors gracefully?
        // .catch(ex => console.log('parsing failed', ex))
    }

    function create_main_fragment$6(state, component) {
        var div, div_class_value;

        function onwindowresize(event) {
            component.freezeTransitions();
        }
        window.addEventListener('resize', onwindowresize);

        function onwindowresize_1(event) {
            component.set({
                windowWidth: this.innerWidth,
            });
        }
        window.addEventListener('resize', onwindowresize_1);

        var current_block_type = select_block_type$5(state);
        var if_block = current_block_type(state, component);

        return {
            c: function create() {
                div = createElement('div');
                if_block.c();
                this.h();
            },

            h: function hydrate() {
                div.className = div_class_value =
                    'responsive-carousel ' +
                    (state.isSmallScreen ? 'is-small-screen' : '') +
                    ' ' +
                    (state.frozen ? 'frozen' : '');
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                if_block.m(div, null);
            },

            p: function update(changed, state) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type$5(state)) &&
                    if_block
                ) {
                    if_block.p(changed, state);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(div, null);
                }

                if (
                    (changed.isSmallScreen || changed.frozen) &&
                    div_class_value !==
                        (div_class_value =
                            'responsive-carousel ' +
                            (state.isSmallScreen ? 'is-small-screen' : '') +
                            ' ' +
                            (state.frozen ? 'frozen' : ''))
                ) {
                    div.className = div_class_value;
                }
            },

            u: function unmount() {
                detachNode(div);
                if_block.u();
            },

            d: function destroy$$1() {
                window.removeEventListener('resize', onwindowresize);

                window.removeEventListener('resize', onwindowresize_1);

                if_block.d();
            },
        };
    }

    // (61:23) {{#each items as item, index}}
    function create_each_block$5(state, items, item, index, component) {
        var button, div, text, text_1, button_class_value;

        return {
            c: function create() {
                button = createElement('button');
                div = createElement('div');
                text = createText('Carousel slide ');
                text_1 = createText(index);
                this.h();
            },

            h: function hydrate() {
                div.className = 'ghost';
                button.className = button_class_value =
                    index === state.selectedIndex ? 'on' : '';
                addListener(button, 'click', click_handler$3);

                button._svelte = {
                    component: component,
                    items: items,
                    index: index,
                };
            },

            m: function mount(target, anchor) {
                insertNode(button, target, anchor);
                appendNode(div, button);
                appendNode(text, div);
                appendNode(text_1, div);
            },

            p: function update(changed, state, items, item, index) {
                if (
                    changed.selectedIndex &&
                    button_class_value !==
                        (button_class_value =
                            index === state.selectedIndex ? 'on' : '')
                ) {
                    button.className = button_class_value;
                }

                button._svelte.items = items;
                button._svelte.index = index;
            },

            u: function unmount() {
                detachNode(button);
            },

            d: function destroy$$1() {
                removeListener(button, 'click', click_handler$3);
            },
        };
    }

    // (67:73) {{#each items as item, index}}
    function create_each_block_1$4(state, items_1, item_1, index, component) {
        var a,
            h3,
            text_value = item_1.formattedMonth,
            text,
            text_1,
            strong,
            text_2_value = item_1.formattedDay,
            text_2,
            text_3,
            h4,
            text_4_value = item_1.title,
            text_4,
            text_5,
            p,
            text_6_value = item_1.formattedTime,
            text_6,
            text_7,
            p_1,
            text_8_value = item_1.text,
            text_8,
            a_class_value,
            a_href_value;

        return {
            c: function create() {
                a = createElement('a');
                h3 = createElement('h3');
                text = createText(text_value);
                text_1 = createText(' ');
                strong = createElement('strong');
                text_2 = createText(text_2_value);
                text_3 = createText('\r\n        ');
                h4 = createElement('h4');
                text_4 = createText(text_4_value);
                text_5 = createText('\r\n        ');
                p = createElement('p');
                text_6 = createText(text_6_value);
                text_7 = createText('\r\n        ');
                p_1 = createElement('p');
                text_8 = createText(text_8_value);
                this.h();
            },

            h: function hydrate() {
                h3.className = 'date';
                h4.className = 'item-title';
                p.className = 'time';
                p_1.className = 'text';
                a.className = a_class_value =
                    'item cell medium-4 ' +
                    item_1.type +
                    ' ' +
                    (index === state.selectedIndex ? 'on' : '');
                a.href = a_href_value = item_1.url;
            },

            m: function mount(target, anchor) {
                insertNode(a, target, anchor);
                appendNode(h3, a);
                appendNode(text, h3);
                appendNode(text_1, h3);
                appendNode(strong, h3);
                appendNode(text_2, strong);
                appendNode(text_3, a);
                appendNode(h4, a);
                appendNode(text_4, h4);
                appendNode(text_5, a);
                appendNode(p, a);
                appendNode(text_6, p);
                appendNode(text_7, a);
                appendNode(p_1, a);
                appendNode(text_8, p_1);
            },

            p: function update(changed, state, items_1, item_1, index) {
                if (
                    changed.items &&
                    text_value !== (text_value = item_1.formattedMonth)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.items &&
                    text_2_value !== (text_2_value = item_1.formattedDay)
                ) {
                    text_2.data = text_2_value;
                }

                if (
                    changed.items &&
                    text_4_value !== (text_4_value = item_1.title)
                ) {
                    text_4.data = text_4_value;
                }

                if (
                    changed.items &&
                    text_6_value !== (text_6_value = item_1.formattedTime)
                ) {
                    text_6.data = text_6_value;
                }

                if (
                    changed.items &&
                    text_8_value !== (text_8_value = item_1.text)
                ) {
                    text_8.data = text_8_value;
                }

                if (
                    (changed.items || changed.selectedIndex) &&
                    a_class_value !==
                        (a_class_value =
                            'item cell medium-4 ' +
                            item_1.type +
                            ' ' +
                            (index === state.selectedIndex ? 'on' : ''))
                ) {
                    a.className = a_class_value;
                }

                if (
                    changed.items &&
                    a_href_value !== (a_href_value = item_1.url)
                ) {
                    a.href = a_href_value;
                }
            },

            u: function unmount() {
                detachNode(a);
            },

            d: noop,
        };
    }

    // (60:103) {{#if loaded}}
    function create_if_block$5(state, component) {
        var div, text_1, div_1, div_2, div_2_style_value;

        var items = state.items;

        var each_blocks = [];

        for (var i = 0; i < items.length; i += 1) {
            each_blocks[i] = create_each_block$5(
                state,
                items,
                items[i],
                i,
                component
            );
        }

        var items_1 = state.items;

        var each_1_blocks = [];

        for (var i = 0; i < items_1.length; i += 1) {
            each_1_blocks[i] = create_each_block_1$4(
                state,
                items_1,
                items_1[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                div = createElement('div');

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                text_1 = createText('\r\n  ');
                div_1 = createElement('div');
                div_2 = createElement('div');

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].c();
                }
                this.h();
            },

            h: function hydrate() {
                div.className = 'indices';
                div_2.className = 'items grid-x grid-margin-x';
                div_2.style.cssText = div_2_style_value =
                    '' + state.transitionStyle + ';';
                div_1.className = 'gutter';
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(div, null);
                }

                insertNode(text_1, target, anchor);
                insertNode(div_1, target, anchor);
                appendNode(div_2, div_1);

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].m(div_2, null);
                }
            },

            p: function update(changed, state) {
                var items = state.items;

                if (changed.selectedIndex || changed.items) {
                    for (var i = 0; i < items.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                items,
                                items[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block$5(
                                state,
                                items,
                                items[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(div, null);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = items.length;
                }

                var items_1 = state.items;

                if (changed.items || changed.selectedIndex) {
                    for (var i = 0; i < items_1.length; i += 1) {
                        if (each_1_blocks[i]) {
                            each_1_blocks[i].p(
                                changed,
                                state,
                                items_1,
                                items_1[i],
                                i
                            );
                        } else {
                            each_1_blocks[i] = create_each_block_1$4(
                                state,
                                items_1,
                                items_1[i],
                                i,
                                component
                            );
                            each_1_blocks[i].c();
                            each_1_blocks[i].m(div_2, null);
                        }
                    }

                    for (; i < each_1_blocks.length; i += 1) {
                        each_1_blocks[i].u();
                        each_1_blocks[i].d();
                    }
                    each_1_blocks.length = items_1.length;
                }

                if (
                    changed.transitionStyle &&
                    div_2_style_value !==
                        (div_2_style_value = '' + state.transitionStyle + ';')
                ) {
                    div_2.style.cssText = div_2_style_value;
                }
            },

            u: function unmount() {
                detachNode(div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                detachNode(text_1);
                detachNode(div_1);

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].u();
                }
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);

                destroyEach(each_1_blocks);
            },
        };
    }

    // (73:8) {{else}}
    function create_if_block_1$5(state, component) {
        var loader = new Loader({
            root: component.root,
        });

        return {
            c: function create() {
                loader._fragment.c();
            },

            m: function mount(target, anchor) {
                loader._mount(target, anchor);
            },

            p: noop,

            u: function unmount() {
                loader._unmount();
            },

            d: function destroy$$1() {
                loader.destroy(false);
            },
        };
    }

    function click_handler$3(event) {
        var component = this._svelte.component;
        var items = this._svelte.items,
            index = this._svelte.index,
            item = items[index];
        component.set({ selectedIndex: index });
    }

    function select_block_type$5(state) {
        if (state.loaded) {
            return create_if_block$5;
        }
        return create_if_block_1$5;
    }

    function ResponsiveCarousel(options) {
        init(this, options);
        this._state = assign(data$4(), options.data);
        this._state.windowWidth = window.innerWidth;
        this._recompute(
            { items: 1, windowWidth: 1, isSmallScreen: 1, selectedIndex: 1 },
            this._state
        );

        var _oncreate = oncreate$6.bind(this);

        if (!options.root) {
            this._oncreate = [_oncreate];
            this._beforecreate = [];
            this._aftercreate = [];
        } else {
            this.root._oncreate.push(_oncreate);
        }

        this._fragment = create_main_fragment$6(this._state, this);

        if (options.target) {
            this._fragment.c();
            this._fragment.m(options.target, options.anchor || null);

            this._lock = true;
            callAll(this._beforecreate);
            callAll(this._oncreate);
            callAll(this._aftercreate);
            this._lock = false;
        }
    }

    assign(ResponsiveCarousel.prototype, methods$4, proto);

    ResponsiveCarousel.prototype._recompute = function _recompute(
        changed,
        state
    ) {
        if (changed.items) {
            if (differs(state.loaded, (state.loaded = loaded$3(state.items)))) {
                changed.loaded = true;
            }
        }

        if (changed.windowWidth) {
            if (
                differs(
                    state.isSmallScreen,
                    (state.isSmallScreen = isSmallScreen(state.windowWidth))
                )
            ) {
                changed.isSmallScreen = true;
            }
        }

        if (
            changed.isSmallScreen ||
            changed.windowWidth ||
            changed.selectedIndex
        ) {
            if (
                differs(
                    state.transitionStyle,
                    (state.transitionStyle = transitionStyle(
                        state.isSmallScreen,
                        state.windowWidth,
                        state.selectedIndex
                    ))
                )
            ) {
                changed.transitionStyle = true;
            }
        }
    };

    /* client/source/app/components/ResponsiveHomeCarousel.html generated by Svelte v1.50.0 */
    // import { tween } from 'svelte-extras'

    function loaded$4(items) {
        return !!items;
    }

    function isSmallScreen$1(windowWidth) {
        return windowWidth < 700 ? true : false;
    }

    function eventsTransitionStyle(
        isSmallScreen,
        windowWidth,
        eventsSelectedIndex
    ) {
        if (isSmallScreen) {
            var itemWidth = windowWidth - 60 + 15;
            return (
                'transform:translateX(' +
                itemWidth * -eventsSelectedIndex +
                'px)'
            );
        }
        return '';
    }

    function newsTransitionStyle(
        isSmallScreen,
        windowWidth,
        newsSelectedIndex
    ) {
        if (isSmallScreen) {
            var itemWidth = windowWidth - 60 + 15;
            return (
                'transform:translateX(' + itemWidth * -newsSelectedIndex + 'px)'
            );
        }
        return '';
    }

    function eventItems(items) {
        return _.filter(items, { type: 'event' });
    }

    function newsItems(items) {
        return _.filter(items, { type: 'news' });
    }

    function data$5() {
        return {
            frozen: false,
        };
    }

    var methods$5 = {
        // tween,
        freezeTransitions: function freezeTransitions() {
            this.set({ frozen: true });
            this.debounceResizeEnd(this);
        },
        debounceResizeEnd: (function () {
            return _.debounce(function () {
                this.set({ frozen: false });
            }, 250);
        })(),
    };

    function oncreate$7() {
        var this$1 = this;

        // one time fetch
        fetch(this.get('url'))
            .then(function (response) {
                return response.json();
            })
            .then(function (json) {
                // console.log(json)
                this$1.set({
                    eventsSelectedIndex: 0,
                    newsSelectedIndex: 0,
                    items: json,
                });
            });
        // TODO: handle errors gracefully?
        // .catch(ex => console.log('parsing failed', ex))
    }

    function create_main_fragment$7(state, component) {
        var if_block_anchor;

        function onwindowresize(event) {
            component.freezeTransitions();
        }
        window.addEventListener('resize', onwindowresize);

        function onwindowresize_1(event) {
            component.set({
                windowWidth: this.innerWidth,
            });
        }
        window.addEventListener('resize', onwindowresize_1);

        var current_block_type = select_block_type_2$3(state);
        var if_block = current_block_type(state, component);

        return {
            c: function create() {
                if_block.c();
                if_block_anchor = createComment();
            },

            m: function mount(target, anchor) {
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type_2$3(state)) &&
                    if_block
                ) {
                    if_block.p(changed, state);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                window.removeEventListener('resize', onwindowresize);

                window.removeEventListener('resize', onwindowresize_1);

                if_block.d();
            },
        };
    }

    // (71:23) {{#each eventItems as item, index}}
    function create_each_block$6(state, eventItems_1, item, index, component) {
        var button, div, text, text_1, button_class_value;

        return {
            c: function create() {
                button = createElement('button');
                div = createElement('div');
                text = createText('Carousel slide ');
                text_1 = createText(index);
                this.h();
            },

            h: function hydrate() {
                div.className = 'ghost';
                button.className = button_class_value =
                    index === state.eventsSelectedIndex ? 'on' : '';
                addListener(button, 'click', click_handler$4);

                button._svelte = {
                    component: component,
                    eventItems_1: eventItems_1,
                    index: index,
                };
            },

            m: function mount(target, anchor) {
                insertNode(button, target, anchor);
                appendNode(div, button);
                appendNode(text, div);
                appendNode(text_1, div);
            },

            p: function update(changed, state, eventItems_1, item, index) {
                if (
                    changed.eventsSelectedIndex &&
                    button_class_value !==
                        (button_class_value =
                            index === state.eventsSelectedIndex ? 'on' : '')
                ) {
                    button.className = button_class_value;
                }

                button._svelte.eventItems_1 = eventItems_1;
                button._svelte.index = index;
            },

            u: function unmount() {
                detachNode(button);
            },

            d: function destroy$$1() {
                removeListener(button, 'click', click_handler$4);
            },
        };
    }

    // (77:79) {{#each eventItems as item, index}}
    function create_each_block_1$5(
        state,
        eventItems_2,
        item_1,
        index,
        component
    ) {
        var a,
            h3,
            text_value = item_1.formattedMonth,
            text,
            text_1,
            strong,
            text_2_value = item_1.formattedDay,
            text_2,
            text_3,
            h4,
            text_4_value = item_1.title,
            text_4,
            text_5,
            p,
            text_6_value = item_1.formattedTime,
            text_6,
            text_7,
            p_1,
            text_8_value = item_1.text,
            text_8,
            a_class_value,
            a_href_value;

        return {
            c: function create() {
                a = createElement('a');
                h3 = createElement('h3');
                text = createText(text_value);
                text_1 = createText(' ');
                strong = createElement('strong');
                text_2 = createText(text_2_value);
                text_3 = createText('\r\n        ');
                h4 = createElement('h4');
                text_4 = createText(text_4_value);
                text_5 = createText('\r\n        ');
                p = createElement('p');
                text_6 = createText(text_6_value);
                text_7 = createText('\r\n        ');
                p_1 = createElement('p');
                text_8 = createText(text_8_value);
                this.h();
            },

            h: function hydrate() {
                h3.className = 'date';
                h4.className = 'item-title';
                p.className = 'time';
                p_1.className = 'text';
                a.className = a_class_value =
                    'item cell medium-4 event ' +
                    (index === state.eventsSelectedIndex ? 'on' : '');
                a.href = a_href_value = item_1.url;
            },

            m: function mount(target, anchor) {
                insertNode(a, target, anchor);
                appendNode(h3, a);
                appendNode(text, h3);
                appendNode(text_1, h3);
                appendNode(strong, h3);
                appendNode(text_2, strong);
                appendNode(text_3, a);
                appendNode(h4, a);
                appendNode(text_4, h4);
                appendNode(text_5, a);
                appendNode(p, a);
                appendNode(text_6, p);
                appendNode(text_7, a);
                appendNode(p_1, a);
                appendNode(text_8, p_1);
            },

            p: function update(changed, state, eventItems_2, item_1, index) {
                if (
                    changed.eventItems &&
                    text_value !== (text_value = item_1.formattedMonth)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.eventItems &&
                    text_2_value !== (text_2_value = item_1.formattedDay)
                ) {
                    text_2.data = text_2_value;
                }

                if (
                    changed.eventItems &&
                    text_4_value !== (text_4_value = item_1.title)
                ) {
                    text_4.data = text_4_value;
                }

                if (
                    changed.eventItems &&
                    text_6_value !== (text_6_value = item_1.formattedTime)
                ) {
                    text_6.data = text_6_value;
                }

                if (
                    changed.eventItems &&
                    text_8_value !== (text_8_value = item_1.text)
                ) {
                    text_8.data = text_8_value;
                }

                if (
                    changed.eventsSelectedIndex &&
                    a_class_value !==
                        (a_class_value =
                            'item cell medium-4 event ' +
                            (index === state.eventsSelectedIndex ? 'on' : ''))
                ) {
                    a.className = a_class_value;
                }

                if (
                    changed.eventItems &&
                    a_href_value !== (a_href_value = item_1.url)
                ) {
                    a.href = a_href_value;
                }
            },

            u: function unmount() {
                detachNode(a);
            },

            d: noop,
        };
    }

    // (87:23) {{#each newsItems as item, index}}
    function create_each_block_2$2(
        state,
        newsItems_1,
        item_2,
        index,
        component
    ) {
        var button, div, text, text_1, button_class_value;

        return {
            c: function create() {
                button = createElement('button');
                div = createElement('div');
                text = createText('Carousel slide ');
                text_1 = createText(index);
                this.h();
            },

            h: function hydrate() {
                div.className = 'ghost';
                button.className = button_class_value =
                    index === state.newsSelectedIndex ? 'on' : '';
                addListener(button, 'click', click_handler_1);

                button._svelte = {
                    component: component,
                    newsItems_1: newsItems_1,
                    index: index,
                };
            },

            m: function mount(target, anchor) {
                insertNode(button, target, anchor);
                appendNode(div, button);
                appendNode(text, div);
                appendNode(text_1, div);
            },

            p: function update(changed, state, newsItems_1, item_2, index) {
                if (
                    changed.newsSelectedIndex &&
                    button_class_value !==
                        (button_class_value =
                            index === state.newsSelectedIndex ? 'on' : '')
                ) {
                    button.className = button_class_value;
                }

                button._svelte.newsItems_1 = newsItems_1;
                button._svelte.index = index;
            },

            u: function unmount() {
                detachNode(button);
            },

            d: function destroy$$1() {
                removeListener(button, 'click', click_handler_1);
            },
        };
    }

    // (93:77) {{#each newsItems as item, index}}
    function create_each_block_3$1(
        state,
        newsItems_2,
        item_3,
        index,
        component
    ) {
        var a,
            div,
            text_value = item_3.imgAlt,
            text,
            text_1,
            div_1,
            h2,
            text_2_value = item_3.title,
            text_2,
            text_3,
            h3,
            text_4_value = item_3.formattedDate,
            text_4,
            a_class_value,
            a_href_value;

        return {
            c: function create() {
                a = createElement('a');
                div = createElement('div');
                text = createText(text_value);
                text_1 = createText('\r\n        ');
                div_1 = createElement('div');
                h2 = createElement('h2');
                text_2 = createText(text_2_value);
                text_3 = createText('\r\n          ');
                h3 = createElement('h3');
                text_4 = createText(text_4_value);
                this.h();
            },

            h: function hydrate() {
                div.className = 'ghost';
                h2.className = 'item-title';
                h3.className = 'date';
                div_1.className = 'fold';
                a.className = a_class_value =
                    'item cell medium-4 news ' +
                    (index === state.newsSelectedIndex ? 'on' : '');
                setStyle(a, 'background-image', 'url(' + item_3.imgSrc + ')');
                a.href = a_href_value = item_3.url;
            },

            m: function mount(target, anchor) {
                insertNode(a, target, anchor);
                appendNode(div, a);
                appendNode(text, div);
                appendNode(text_1, a);
                appendNode(div_1, a);
                appendNode(h2, div_1);
                appendNode(text_2, h2);
                appendNode(text_3, div_1);
                appendNode(h3, div_1);
                appendNode(text_4, h3);
            },

            p: function update(changed, state, newsItems_2, item_3, index) {
                if (
                    changed.newsItems &&
                    text_value !== (text_value = item_3.imgAlt)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.newsItems &&
                    text_2_value !== (text_2_value = item_3.title)
                ) {
                    text_2.data = text_2_value;
                }

                if (
                    changed.newsItems &&
                    text_4_value !== (text_4_value = item_3.formattedDate)
                ) {
                    text_4.data = text_4_value;
                }

                if (
                    changed.newsSelectedIndex &&
                    a_class_value !==
                        (a_class_value =
                            'item cell medium-4 news ' +
                            (index === state.newsSelectedIndex ? 'on' : ''))
                ) {
                    a.className = a_class_value;
                }

                if (changed.newsItems) {
                    setStyle(
                        a,
                        'background-image',
                        'url(' + item_3.imgSrc + ')'
                    );
                }

                if (
                    changed.newsItems &&
                    a_href_value !== (a_href_value = item_3.url)
                ) {
                    a.href = a_href_value;
                }
            },

            u: function unmount() {
                detachNode(a);
            },

            d: noop,
        };
    }

    // (105:44) {{#each items as item, index}}
    function create_each_block_4$1(state, items, item, index, component) {
        var if_block_anchor;

        var current_block_type = select_block_type$6(state, items, item, index);
        var if_block = current_block_type(state, items, item, index, component);

        return {
            c: function create() {
                if_block.c();
                if_block_anchor = createComment();
            },

            m: function mount(target, anchor) {
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state, items, item, index) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type$6(
                            state,
                            items,
                            item,
                            index
                        )) &&
                    if_block
                ) {
                    if_block.p(changed, state, items, item, index);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(
                        state,
                        items,
                        item,
                        index,
                        component
                    );
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                if_block.d();
            },
        };
    }

    // (105:74) {{#if item.type === 'event'}}
    function create_if_block_3$4(state, items, item, index, component) {
        var a,
            h3,
            text_value = item.formattedMonth,
            text,
            text_1,
            strong,
            text_2_value = item.formattedDay,
            text_2,
            text_3,
            h4,
            text_4_value = item.title,
            text_4,
            text_5,
            p,
            text_6_value = item.formattedTime,
            text_6,
            text_7,
            p_1,
            text_8_value = item.text,
            text_8,
            a_href_value;

        return {
            c: function create() {
                a = createElement('a');
                h3 = createElement('h3');
                text = createText(text_value);
                text_1 = createText(' ');
                strong = createElement('strong');
                text_2 = createText(text_2_value);
                text_3 = createText('\r\n        ');
                h4 = createElement('h4');
                text_4 = createText(text_4_value);
                text_5 = createText('\r\n        ');
                p = createElement('p');
                text_6 = createText(text_6_value);
                text_7 = createText('\r\n        ');
                p_1 = createElement('p');
                text_8 = createText(text_8_value);
                this.h();
            },

            h: function hydrate() {
                h3.className = 'date';
                h4.className = 'item-title';
                p.className = 'time';
                p_1.className = 'text';
                a.className = 'item cell medium-4 event';
                a.href = a_href_value = item.url;
            },

            m: function mount(target, anchor) {
                insertNode(a, target, anchor);
                appendNode(h3, a);
                appendNode(text, h3);
                appendNode(text_1, h3);
                appendNode(strong, h3);
                appendNode(text_2, strong);
                appendNode(text_3, a);
                appendNode(h4, a);
                appendNode(text_4, h4);
                appendNode(text_5, a);
                appendNode(p, a);
                appendNode(text_6, p);
                appendNode(text_7, a);
                appendNode(p_1, a);
                appendNode(text_8, p_1);
            },

            p: function update(changed, state, items, item, index) {
                if (
                    changed.items &&
                    text_value !== (text_value = item.formattedMonth)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.items &&
                    text_2_value !== (text_2_value = item.formattedDay)
                ) {
                    text_2.data = text_2_value;
                }

                if (
                    changed.items &&
                    text_4_value !== (text_4_value = item.title)
                ) {
                    text_4.data = text_4_value;
                }

                if (
                    changed.items &&
                    text_6_value !== (text_6_value = item.formattedTime)
                ) {
                    text_6.data = text_6_value;
                }

                if (
                    changed.items &&
                    text_8_value !== (text_8_value = item.text)
                ) {
                    text_8.data = text_8_value;
                }

                if (
                    changed.items &&
                    a_href_value !== (a_href_value = item.url)
                ) {
                    a.href = a_href_value;
                }
            },

            u: function unmount() {
                detachNode(a);
            },

            d: noop,
        };
    }

    // (109:46) {{else}}
    function create_if_block_4$3(state, items, item, index, component) {
        var a,
            div,
            text_value = item.imgAlt,
            text,
            text_1,
            div_1,
            h3,
            text_2_value = item.title,
            text_2,
            text_3,
            h4,
            text_4_value = item.formattedDate,
            text_4,
            a_href_value;

        return {
            c: function create() {
                a = createElement('a');
                div = createElement('div');
                text = createText(text_value);
                text_1 = createText('\r\n        ');
                div_1 = createElement('div');
                h3 = createElement('h3');
                text_2 = createText(text_2_value);
                text_3 = createText('\r\n          ');
                h4 = createElement('h4');
                text_4 = createText(text_4_value);
                this.h();
            },

            h: function hydrate() {
                div.className = 'ghost';
                h3.className = 'item-title';
                h4.className = 'date';
                div_1.className = 'fold';
                a.className = 'item cell medium-4 news';
                setStyle(a, 'background-image', 'url(' + item.imgSrc + ')');
                a.href = a_href_value = item.url;
            },

            m: function mount(target, anchor) {
                insertNode(a, target, anchor);
                appendNode(div, a);
                appendNode(text, div);
                appendNode(text_1, a);
                appendNode(div_1, a);
                appendNode(h3, div_1);
                appendNode(text_2, h3);
                appendNode(text_3, div_1);
                appendNode(h4, div_1);
                appendNode(text_4, h4);
            },

            p: function update(changed, state, items, item, index) {
                if (
                    changed.items &&
                    text_value !== (text_value = item.imgAlt)
                ) {
                    text.data = text_value;
                }

                if (
                    changed.items &&
                    text_2_value !== (text_2_value = item.title)
                ) {
                    text_2.data = text_2_value;
                }

                if (
                    changed.items &&
                    text_4_value !== (text_4_value = item.formattedDate)
                ) {
                    text_4.data = text_4_value;
                }

                if (changed.items) {
                    setStyle(a, 'background-image', 'url(' + item.imgSrc + ')');
                }

                if (
                    changed.items &&
                    a_href_value !== (a_href_value = item.url)
                ) {
                    a.href = a_href_value;
                }
            },

            u: function unmount() {
                detachNode(a);
            },

            d: noop,
        };
    }

    // (69:95) {{#if isSmallScreen}}
    function create_if_block_1$6(state, component) {
        var div,
            div_1,
            text_1,
            div_2,
            div_3,
            div_3_style_value,
            text_4,
            div_4,
            a,
            span,
            text_5,
            text_6_value = state.itemsIndex === 0 ? 'Events' : 'News',
            text_6,
            div_class_value,
            text_8,
            div_5,
            div_6,
            text_10,
            div_7,
            div_8,
            div_8_style_value,
            text_13,
            div_9,
            a_1,
            span_1,
            text_14,
            text_15_value = state.itemsIndex === 0 ? 'Events' : 'News',
            text_15,
            div_5_class_value;

        var eventItems_1 = state.eventItems;

        var each_blocks = [];

        for (var i = 0; i < eventItems_1.length; i += 1) {
            each_blocks[i] = create_each_block$6(
                state,
                eventItems_1,
                eventItems_1[i],
                i,
                component
            );
        }

        var eventItems_2 = state.eventItems;

        var each_1_blocks = [];

        for (var i = 0; i < eventItems_2.length; i += 1) {
            each_1_blocks[i] = create_each_block_1$5(
                state,
                eventItems_2,
                eventItems_2[i],
                i,
                component
            );
        }

        var newsItems_1 = state.newsItems;

        var each_2_blocks = [];

        for (var i = 0; i < newsItems_1.length; i += 1) {
            each_2_blocks[i] = create_each_block_2$2(
                state,
                newsItems_1,
                newsItems_1[i],
                i,
                component
            );
        }

        var newsItems_2 = state.newsItems;

        var each_3_blocks = [];

        for (var i = 0; i < newsItems_2.length; i += 1) {
            each_3_blocks[i] = create_each_block_3$1(
                state,
                newsItems_2,
                newsItems_2[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }

                text_1 = createText('\r\n  ');
                div_2 = createElement('div');
                div_3 = createElement('div');

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].c();
                }

                text_4 = createText('\r\n  ');
                div_4 = createElement('div');
                a = createElement('a');
                span = createElement('span');
                text_5 = createText('All ');
                text_6 = createText(text_6_value);
                text_8 = createText('\r\n');
                div_5 = createElement('div');
                div_6 = createElement('div');

                for (var i = 0; i < each_2_blocks.length; i += 1) {
                    each_2_blocks[i].c();
                }

                text_10 = createText('\r\n  ');
                div_7 = createElement('div');
                div_8 = createElement('div');

                for (var i = 0; i < each_3_blocks.length; i += 1) {
                    each_3_blocks[i].c();
                }

                text_13 = createText('\r\n  ');
                div_9 = createElement('div');
                a_1 = createElement('a');
                span_1 = createElement('span');
                text_14 = createText('All ');
                text_15 = createText(text_15_value);
                this.h();
            },

            h: function hydrate() {
                div_1.className = 'indices';
                div_3.className = 'items grid-x grid-margin-x';
                div_3.style.cssText = div_3_style_value =
                    '' + state.eventsTransitionStyle + ';';
                div_2.className = 'gutter';
                a.className = 'button';
                a.href = '/all-events';
                div_4.className = 'button-group';
                div.className = div_class_value =
                    'responsive-carousel events-carousel is-small-screen ' +
                    (state.frozen ? 'frozen' : '');
                div_6.className = 'indices';
                div_8.className = 'items grid-x grid-margin-x';
                div_8.style.cssText = div_8_style_value =
                    '' + state.newsTransitionStyle + ';';
                div_7.className = 'gutter';
                a_1.className = 'button';
                a_1.href = '/all-events';
                div_9.className = 'button-group';
                div_5.className = div_5_class_value =
                    'responsive-carousel news-carousel is-small-screen ' +
                    (state.frozen ? 'frozen' : '');
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(div_1, null);
                }

                appendNode(text_1, div);
                appendNode(div_2, div);
                appendNode(div_3, div_2);

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].m(div_3, null);
                }

                appendNode(text_4, div);
                appendNode(div_4, div);
                appendNode(a, div_4);
                appendNode(span, a);
                appendNode(text_5, span);
                appendNode(text_6, span);
                insertNode(text_8, target, anchor);
                insertNode(div_5, target, anchor);
                appendNode(div_6, div_5);

                for (var i = 0; i < each_2_blocks.length; i += 1) {
                    each_2_blocks[i].m(div_6, null);
                }

                appendNode(text_10, div_5);
                appendNode(div_7, div_5);
                appendNode(div_8, div_7);

                for (var i = 0; i < each_3_blocks.length; i += 1) {
                    each_3_blocks[i].m(div_8, null);
                }

                appendNode(text_13, div_5);
                appendNode(div_9, div_5);
                appendNode(a_1, div_9);
                appendNode(span_1, a_1);
                appendNode(text_14, span_1);
                appendNode(text_15, span_1);
            },

            p: function update(changed, state) {
                var eventItems_1 = state.eventItems;

                if (changed.eventsSelectedIndex || changed.eventItems) {
                    for (var i = 0; i < eventItems_1.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                eventItems_1,
                                eventItems_1[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block$6(
                                state,
                                eventItems_1,
                                eventItems_1[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(div_1, null);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = eventItems_1.length;
                }

                var eventItems_2 = state.eventItems;

                if (changed.eventsSelectedIndex || changed.eventItems) {
                    for (var i = 0; i < eventItems_2.length; i += 1) {
                        if (each_1_blocks[i]) {
                            each_1_blocks[i].p(
                                changed,
                                state,
                                eventItems_2,
                                eventItems_2[i],
                                i
                            );
                        } else {
                            each_1_blocks[i] = create_each_block_1$5(
                                state,
                                eventItems_2,
                                eventItems_2[i],
                                i,
                                component
                            );
                            each_1_blocks[i].c();
                            each_1_blocks[i].m(div_3, null);
                        }
                    }

                    for (; i < each_1_blocks.length; i += 1) {
                        each_1_blocks[i].u();
                        each_1_blocks[i].d();
                    }
                    each_1_blocks.length = eventItems_2.length;
                }

                if (
                    changed.eventsTransitionStyle &&
                    div_3_style_value !==
                        (div_3_style_value =
                            '' + state.eventsTransitionStyle + ';')
                ) {
                    div_3.style.cssText = div_3_style_value;
                }

                if (
                    changed.itemsIndex &&
                    text_6_value !==
                        (text_6_value =
                            state.itemsIndex === 0 ? 'Events' : 'News')
                ) {
                    text_6.data = text_6_value;
                }

                if (
                    changed.frozen &&
                    div_class_value !==
                        (div_class_value =
                            'responsive-carousel events-carousel is-small-screen ' +
                            (state.frozen ? 'frozen' : ''))
                ) {
                    div.className = div_class_value;
                }

                var newsItems_1 = state.newsItems;

                if (changed.newsSelectedIndex || changed.newsItems) {
                    for (var i = 0; i < newsItems_1.length; i += 1) {
                        if (each_2_blocks[i]) {
                            each_2_blocks[i].p(
                                changed,
                                state,
                                newsItems_1,
                                newsItems_1[i],
                                i
                            );
                        } else {
                            each_2_blocks[i] = create_each_block_2$2(
                                state,
                                newsItems_1,
                                newsItems_1[i],
                                i,
                                component
                            );
                            each_2_blocks[i].c();
                            each_2_blocks[i].m(div_6, null);
                        }
                    }

                    for (; i < each_2_blocks.length; i += 1) {
                        each_2_blocks[i].u();
                        each_2_blocks[i].d();
                    }
                    each_2_blocks.length = newsItems_1.length;
                }

                var newsItems_2 = state.newsItems;

                if (changed.newsSelectedIndex || changed.newsItems) {
                    for (var i = 0; i < newsItems_2.length; i += 1) {
                        if (each_3_blocks[i]) {
                            each_3_blocks[i].p(
                                changed,
                                state,
                                newsItems_2,
                                newsItems_2[i],
                                i
                            );
                        } else {
                            each_3_blocks[i] = create_each_block_3$1(
                                state,
                                newsItems_2,
                                newsItems_2[i],
                                i,
                                component
                            );
                            each_3_blocks[i].c();
                            each_3_blocks[i].m(div_8, null);
                        }
                    }

                    for (; i < each_3_blocks.length; i += 1) {
                        each_3_blocks[i].u();
                        each_3_blocks[i].d();
                    }
                    each_3_blocks.length = newsItems_2.length;
                }

                if (
                    changed.newsTransitionStyle &&
                    div_8_style_value !==
                        (div_8_style_value =
                            '' + state.newsTransitionStyle + ';')
                ) {
                    div_8.style.cssText = div_8_style_value;
                }

                if (
                    changed.itemsIndex &&
                    text_15_value !==
                        (text_15_value =
                            state.itemsIndex === 0 ? 'Events' : 'News')
                ) {
                    text_15.data = text_15_value;
                }

                if (
                    changed.frozen &&
                    div_5_class_value !==
                        (div_5_class_value =
                            'responsive-carousel news-carousel is-small-screen ' +
                            (state.frozen ? 'frozen' : ''))
                ) {
                    div_5.className = div_5_class_value;
                }
            },

            u: function unmount() {
                detachNode(div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }

                for (var i = 0; i < each_1_blocks.length; i += 1) {
                    each_1_blocks[i].u();
                }

                detachNode(text_8);
                detachNode(div_5);

                for (var i = 0; i < each_2_blocks.length; i += 1) {
                    each_2_blocks[i].u();
                }

                for (var i = 0; i < each_3_blocks.length; i += 1) {
                    each_3_blocks[i].u();
                }
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);

                destroyEach(each_1_blocks);

                destroyEach(each_2_blocks);

                destroyEach(each_3_blocks);
            },
        };
    }

    // (102:6) {{else}}
    function create_if_block_2$4(state, component) {
        var div, div_1, div_2, div_class_value;

        var items = state.items;

        var each_blocks = [];

        for (var i = 0; i < items.length; i += 1) {
            each_blocks[i] = create_each_block_4$1(
                state,
                items,
                items[i],
                i,
                component
            );
        }

        return {
            c: function create() {
                div = createElement('div');
                div_1 = createElement('div');
                div_2 = createElement('div');

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].c();
                }
                this.h();
            },

            h: function hydrate() {
                div_2.className = 'items grid-x grid-margin-x';
                div_1.className = 'gutter';
                div.className = div_class_value =
                    'responsive-carousel ' + (state.frozen ? 'frozen' : '');
            },

            m: function mount(target, anchor) {
                insertNode(div, target, anchor);
                appendNode(div_1, div);
                appendNode(div_2, div_1);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].m(div_2, null);
                }
            },

            p: function update(changed, state) {
                var items = state.items;

                if (changed.items) {
                    for (var i = 0; i < items.length; i += 1) {
                        if (each_blocks[i]) {
                            each_blocks[i].p(
                                changed,
                                state,
                                items,
                                items[i],
                                i
                            );
                        } else {
                            each_blocks[i] = create_each_block_4$1(
                                state,
                                items,
                                items[i],
                                i,
                                component
                            );
                            each_blocks[i].c();
                            each_blocks[i].m(div_2, null);
                        }
                    }

                    for (; i < each_blocks.length; i += 1) {
                        each_blocks[i].u();
                        each_blocks[i].d();
                    }
                    each_blocks.length = items.length;
                }

                if (
                    changed.frozen &&
                    div_class_value !==
                        (div_class_value =
                            'responsive-carousel ' +
                            (state.frozen ? 'frozen' : ''))
                ) {
                    div.className = div_class_value;
                }
            },

            u: function unmount() {
                detachNode(div);

                for (var i = 0; i < each_blocks.length; i += 1) {
                    each_blocks[i].u();
                }
            },

            d: function destroy$$1() {
                destroyEach(each_blocks);
            },
        };
    }

    // (69:81) {{#if loaded}}
    function create_if_block$6(state, component) {
        var if_block_anchor;

        var current_block_type = select_block_type_1$4(state);
        var if_block = current_block_type(state, component);

        return {
            c: function create() {
                if_block.c();
                if_block_anchor = createComment();
            },

            m: function mount(target, anchor) {
                if_block.m(target, anchor);
                insertNode(if_block_anchor, target, anchor);
            },

            p: function update(changed, state) {
                if (
                    current_block_type ===
                        (current_block_type = select_block_type_1$4(state)) &&
                    if_block
                ) {
                    if_block.p(changed, state);
                } else {
                    if_block.u();
                    if_block.d();
                    if_block = current_block_type(state, component);
                    if_block.c();
                    if_block.m(if_block_anchor.parentNode, if_block_anchor);
                }
            },

            u: function unmount() {
                if_block.u();
                detachNode(if_block_anchor);
            },

            d: function destroy$$1() {
                if_block.d();
            },
        };
    }

    // (117:13) {{else}}
    function create_if_block_5$3(state, component) {
        var loader = new Loader({
            root: component.root,
        });

        return {
            c: function create() {
                loader._fragment.c();
            },

            m: function mount(target, anchor) {
                loader._mount(target, anchor);
            },

            p: noop,

            u: function unmount() {
                loader._unmount();
            },

            d: function destroy$$1() {
                loader.destroy(false);
            },
        };
    }

    function click_handler$4(event) {
        var component = this._svelte.component;
        var eventItems_1 = this._svelte.eventItems_1,
            index = this._svelte.index,
            item = eventItems_1[index];
        component.set({ eventsSelectedIndex: index });
    }

    function click_handler_1(event) {
        var component = this._svelte.component;
        var newsItems_1 = this._svelte.newsItems_1,
            index = this._svelte.index,
            item_2 = newsItems_1[index];
        component.set({ newsSelectedIndex: index });
    }

    function select_block_type$6(state, items, item, index) {
        if (item.type === 'event') {
            return create_if_block_3$4;
        }
        return create_if_block_4$3;
    }

    function select_block_type_1$4(state) {
        if (state.isSmallScreen) {
            return create_if_block_1$6;
        }
        return create_if_block_2$4;
    }

    function select_block_type_2$3(state) {
        if (state.loaded) {
            return create_if_block$6;
        }
        return create_if_block_5$3;
    }

    function ResponsiveHomeCarousel(options) {
        init(this, options);
        this._state = assign(data$5(), options.data);
        this._state.windowWidth = window.innerWidth;
        this._recompute(
            {
                items: 1,
                windowWidth: 1,
                isSmallScreen: 1,
                eventsSelectedIndex: 1,
                newsSelectedIndex: 1,
            },
            this._state
        );

        var _oncreate = oncreate$7.bind(this);

        if (!options.root) {
            this._oncreate = [_oncreate];
            this._beforecreate = [];
            this._aftercreate = [];
        } else {
            this.root._oncreate.push(_oncreate);
        }

        this._fragment = create_main_fragment$7(this._state, this);

        if (options.target) {
            this._fragment.c();
            this._fragment.m(options.target, options.anchor || null);

            this._lock = true;
            callAll(this._beforecreate);
            callAll(this._oncreate);
            callAll(this._aftercreate);
            this._lock = false;
        }
    }

    assign(ResponsiveHomeCarousel.prototype, methods$5, proto);

    ResponsiveHomeCarousel.prototype._recompute = function _recompute(
        changed,
        state
    ) {
        if (changed.items) {
            if (differs(state.loaded, (state.loaded = loaded$4(state.items)))) {
                changed.loaded = true;
            }
        }

        if (changed.windowWidth) {
            if (
                differs(
                    state.isSmallScreen,
                    (state.isSmallScreen = isSmallScreen$1(state.windowWidth))
                )
            ) {
                changed.isSmallScreen = true;
            }
        }

        if (
            changed.isSmallScreen ||
            changed.windowWidth ||
            changed.eventsSelectedIndex
        ) {
            if (
                differs(
                    state.eventsTransitionStyle,
                    (state.eventsTransitionStyle = eventsTransitionStyle(
                        state.isSmallScreen,
                        state.windowWidth,
                        state.eventsSelectedIndex
                    ))
                )
            ) {
                changed.eventsTransitionStyle = true;
            }
        }

        if (
            changed.isSmallScreen ||
            changed.windowWidth ||
            changed.newsSelectedIndex
        ) {
            if (
                differs(
                    state.newsTransitionStyle,
                    (state.newsTransitionStyle = newsTransitionStyle(
                        state.isSmallScreen,
                        state.windowWidth,
                        state.newsSelectedIndex
                    ))
                )
            ) {
                changed.newsTransitionStyle = true;
            }
        }

        if (changed.items) {
            if (
                differs(
                    state.eventItems,
                    (state.eventItems = eventItems(state.items))
                )
            ) {
                changed.eventItems = true;
            }
            if (
                differs(
                    state.newsItems,
                    (state.newsItems = newsItems(state.items))
                )
            ) {
                changed.newsItems = true;
            }
        }
    };

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Component: `.reveal`
     * Used to contain reveal content
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $html = document.querySelector('html');
    var $reveal = document.querySelector('.reveal');
    var $body = document.querySelector('.reveal .body');

    var $fReveal = $($reveal);

    var Reveal = {
        $body: $body,

        open: function open(options) {
            options = options || {};

            $html.classList.remove('header-up');
            $fReveal.foundation('open');
            if (options.classes) {
                _.each(options.classes, function (className) {
                    return $reveal.classList.add(className);
                });
            }

            setFocus($reveal);

            $(document).on('closed.zf.reveal', function () {
                $fReveal.foundation('close');
                if (options.classes) {
                    _.each(options.classes, function (className) {
                        return $reveal.classList.remove(className);
                    });
                }
                if (options.onClose) {
                    options.onClose(options.payload);
                }
                $(document).off('closed.zf.reveal');
            });
        },
    };

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Component: `.video`
     * for playing video on pages and in carousels
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    function Video() {
        // trigger playing videos
        var $player;
        _.each(document.querySelectorAll('.video-media'), function ($video) {
            var $button = $video.querySelector('button');
            var $content = $video.querySelector('.video-reveal-content');
            var $frame = $video.querySelector('.video-frame');

            // inject youtube api script
            if (!window.ifactoryYouTubeInjected) {
                window.ifactoryYouTubeInjected = true;
                var script = document.createElement('script');
                script.src = '//www.youtube.com/iframe_api';
                document.querySelector('.hidden-js').appendChild(script);
            }

            $button.addEventListener('click', function (event) {
                event.preventDefault();

                $content.removeAttribute('aria-hidden');

                Reveal.$body.appendChild($content);
                var $replace = document.createElement('div');
                $replace.id = 'youtube-player';
                $frame.appendChild($replace);
                $player = new YT.Player('youtube-player', {
                    width: '560',
                    height: '315',
                    videoId: $content.dataset.youtubeid,
                    // host: 'https://www.youtube.com',
                    playerVars: {
                        rel: 0,
                        showinfo: 0,
                        autoplay: 0,
                    },
                    events: {
                        onReady: function onReady() {
                            $player.playVideo();
                        },
                    },
                });
                // this craziness accounts for aspect ratio changes on different display heights / widths
                var resizeVideo = _.throttle(function () {
                    var dimensions = viewportDimensions();
                    var revealAspect;
                    if (dimensions.width < 700) {
                        revealAspect =
                            (dimensions.height - 120) / dimensions.width;
                    } else if (dimensions.width < 1024) {
                        revealAspect =
                            (dimensions.height - 60) / (dimensions.width - 60);
                    } else {
                        revealAspect =
                            (dimensions.height - 60) / (dimensions.width - 80);
                    }
                    // aspect ratio = 16:9 = 100 * 9/16
                    if (revealAspect < 9 / 16) {
                        $frame.style.paddingBottom = revealAspect * 100 + '%';
                    } else {
                        $frame.removeAttribute('style');
                    }
                }, 100);
                resizeVideo();
                window.addEventListener('resize', resizeVideo);

                Reveal.open({
                    classes: ['video-reveal'],
                    onClose: function onClose() {
                        var $iframe = document.querySelector('#youtube-player');
                        $iframe.parentNode.removeChild($iframe);
                        $content.setAttribute('aria-hidden', 'true');
                        $video.appendChild($content);
                        window.removeEventListener('resize', resizeVideo);
                        setFocus($video);
                    },
                });
            });
        });
    }

    // import parse from 'date-fns/parse'
    // import differenceInHours from 'date-fns/difference_in_hours'
    // import differenceInMinutes from 'date-fns/difference_in_minutes'
    // import differenceInSeconds from 'date-fns/difference_in_seconds'

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * This YavaScript is a helper for the Calendar page/module
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    function Calendar() {
        window.addEventListener('DOMContentLoaded', function () {
            // for CSS purposes, the elements need to be in a particular order, with wrappers

            var $catCol = document.querySelector('#hcFilter .catCol');
            var $$catLabels = $catCol.querySelectorAll('label');
            _.each($$catLabels, function ($label) {
                var $div = document.createElement('div');
                $div.classList.add('checkbox');
                $label.parentNode.insertBefore($div, $label);
                $div.appendChild($label);
                var $input = $label.querySelector('input');
                $div.insertBefore($input, $label);
            });

            var $$headers = document.querySelectorAll('#events .header');
            _.each($$headers, function ($header) {
                var $ul = $header.nextElementSibling;
                var $div = document.createElement('div');
                $div.classList.add('day-group');

                $header.parentNode.insertBefore($div, $header);
                $div.appendChild($header);
                $div.appendChild($ul);
            });
            var $eventsWrap = document.createElement('div');
            $eventsWrap.classList.add('events-wrap');
            var $$groups = document.querySelectorAll('#events .day-group');
            $$groups[0].parentNode.insertBefore($eventsWrap, $$groups[0]);
            _.each($$groups, function ($group) {
                $eventsWrap.appendChild($group);
            });

            var then;
            var $$times = document.querySelectorAll(
                '#events .events-wrap time'
            );
            _.each($$times, function ($time) {
                // create day/year wrapper
                var $div = document.createElement('div');
                $div.classList.add('day-year');
                var thenString = $time.getAttribute('datetime');
                var ref = thenString.substr(0, 10).split('-');
                var year = ref[0];
                var month = ref[1];
                var day = ref[2];
                then = new Date(year, month - 1, day);
                $div.innerHTML =
                    format_1(then, 'MMM') +
                    ' <span>' +
                    format_1(then, 'D') +
                    '</span>';
                $time.parentNode.insertBefore($div, $time);

                $time.innerHTML =
                    format_1(then, 'MMMM D, YYYY') + '<br>' + $time.textContent;

                // wrap all other elements
                var $content = document.createElement('div');
                $content.classList.add('content');
                $time.parentNode.insertBefore($content, $time);
                var $elem = $time;
                var $elemToMove;
                while ($elem) {
                    $elemToMove = $elem;
                    $elem = $elem.nextElementSibling;
                    $content.appendChild($elemToMove);
                }
            });

            var $$navs = document.querySelectorAll('#events .event-list-nav');
            _.each($$navs, function ($nav) {
                var $divider = document.createElement('li');
                $divider.classList.add('divider');
                $nav.insertBefore($divider, $nav.childNodes[6]);

                var $month = document.createElement('li');
                $month.classList.add('month-name');
                $month.textContent = format_1(then, 'MMMM');
                $nav.appendChild($month);
            });

            var $layoutWrap = document.createElement('div');
            $layoutWrap.classList.add('layout-wrap');
            var $calendar = document.querySelector('.calendar-section');
            var $filter = document.querySelector('.calendar-section > #filter');
            var $aside = document.querySelector('.calendar-section > aside');
            var $events = document.querySelector('.calendar-section > #events');

            $calendar.appendChild($layoutWrap);
            $calendar.appendChild($events);
            $layoutWrap.appendChild($aside);
            $layoutWrap.appendChild($filter);

            document
                .querySelector('.calendar-section')
                .classList.add('fouc-done');
        });
    }

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Global `window.app` object
     * @global {object} app - contains components and other global functionality
     *     @function TwitterBlock
     *     @function ProgramsList
     *     @function NewsList
     *     @function EventsList
     *     @function Directory
     *     @function ResponsiveCarousel
     *     @function ResponsiveHomeCarousel
     *     @function Video
     *     @function Calendar
     *
     * To invoke a specific component on any given specific page, invoke it by namespace:
     *     <script>window.app.Calendar()</script>
     *
     * NOTE: componenents reuire a`selector` as the first argument:
     *     <script>window.app.TwitterBlock('#some-specific-DOM-element-ID')</script>
     *
     * This use of components allows minification of JS files into a single file,
     * without needing to break them up for different pages.
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    window.app = {
        TwitterBlock: function (target, url) {
            return new TwitterBlock({
                target: document.querySelector(target),
                data: { url: url },
            });
        },
        ProgramsList: function (target, url) {
            return new ProgramsList({
                target: document.querySelector(target),
                data: { url: url },
            });
        },
        NewsList: function (target, url) {
            return new NewsList({
                target: document.querySelector(target),
                data: { url: url },
            });
        },
        EventsList: function (target, url) {
            return new EventsList({
                target: document.querySelector(target),
                data: { url: url },
            });
        },
        Directory: function (target, url) {
            return new Directory({
                target: document.querySelector(target),
                data: { url: url },
            });
        },
        ResponsiveCarousel: function (target, url) {
            return new ResponsiveCarousel({
                target: document.querySelector(target),
                data: { url: url },
            });
        },
        ResponsiveHomeCarousel: function (target, url) {
            return new ResponsiveHomeCarousel({
                target: document.querySelector(target),
                data: { url: url },
            });
        },
        Video: Video,
        Calendar: Calendar,
    };

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Component: `.accordion-block`
     * This expands / collapses all accordions
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    _.each(
        document.querySelectorAll('.accordion-block'),
        function ($accordionBlock) {
            var $expandAll = $accordionBlock.querySelector('.expand-all');
            var $collapseAll = $accordionBlock.querySelector('.collapse-all');
            var $$toggles =
                $accordionBlock.querySelectorAll('.accordion-title');

            if ($expandAll && $collapseAll) {
                _.each($$toggles, function ($toggle) {
                    $toggle.addEventListener('click', function () {
                        var expanded =
                            $toggle.getAttribute('aria-expanded') === 'true';
                        if (expanded) {
                            $collapseAll.removeAttribute('aria-expanded');
                            $collapseAll.disabled = false;
                            if (
                                _.map($$toggles, function ($toggle) {
                                    return $toggle.getAttribute(
                                        'aria-expanded'
                                    );
                                }).indexOf('false') < 0
                            ) {
                                $expandAll.setAttribute(
                                    'aria-expanded',
                                    'true'
                                );
                                $expandAll.disabled = true;
                            }
                        } else {
                            $expandAll.removeAttribute('aria-expanded');
                            $expandAll.disabled = false;
                            if (
                                _.map($$toggles, function ($toggle) {
                                    return $toggle.getAttribute(
                                        'aria-expanded'
                                    );
                                }).indexOf('true') < 0
                            ) {
                                $collapseAll.setAttribute(
                                    'aria-expanded',
                                    'false'
                                );
                                $collapseAll.disabled = true;
                            }
                        }
                    });
                    $toggle.addEventListener('keydown', function () {
                        if (event.keyCode === 13 || event.keyCode === 32) {
                            var expanded =
                                $toggle.getAttribute('aria-expanded') ===
                                'true';
                            if (expanded) {
                                $collapseAll.removeAttribute('aria-expanded');
                                $collapseAll.disabled = false;
                                if (
                                    _.map($$toggles, function ($toggle) {
                                        return $toggle.getAttribute(
                                            'aria-expanded'
                                        );
                                    }).indexOf('false') < 0
                                ) {
                                    $expandAll.setAttribute(
                                        'aria-expanded',
                                        'true'
                                    );
                                    $expandAll.disabled = true;
                                }
                            } else {
                                $expandAll.removeAttribute('aria-expanded');
                                $expandAll.disabled = false;
                                if (
                                    _.map($$toggles, function ($toggle) {
                                        return $toggle.getAttribute(
                                            'aria-expanded'
                                        );
                                    }).indexOf('true') < 0
                                ) {
                                    $collapseAll.setAttribute(
                                        'aria-expanded',
                                        'false'
                                    );
                                    $collapseAll.disabled = true;
                                }
                            }
                        }
                    });
                });

                $expandAll.addEventListener('click', function () {
                    $expandAll.setAttribute('aria-expanded', 'true');
                    $expandAll.disabled = true;
                    $collapseAll.removeAttribute('aria-expanded');
                    $collapseAll.disabled = false;
                    _.each($$toggles, function ($toggle) {
                        if ($toggle.getAttribute('aria-expanded') === 'false') {
                            $($toggle).click();
                        }
                    });
                });

                $collapseAll.addEventListener('click', function () {
                    $collapseAll.setAttribute('aria-expanded', 'false');
                    $collapseAll.disabled = true;
                    $expandAll.removeAttribute('aria-expanded');
                    $expandAll.disabled = false;
                    _.each($$toggles, function ($toggle) {
                        if ($toggle.getAttribute('aria-expanded') === 'true') {
                            $($toggle).click();
                        }
                    });
                });
            }

            // jump to the top of any given accordion
            _.each(
                $accordionBlock.querySelectorAll('.back-to-top'),
                function ($backToTop) {
                    $backToTop.addEventListener('click', function (event) {
                        event.preventDefault();
                        window.scroll(
                            0,
                            $accordionBlock.getBoundingClientRect().top +
                                window.pageYOffset -
                                125
                        );
                    });
                }
            );
        }
    );

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * GENERAL LAYOUT FUNCTIONALITY
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * RESPONSIVE CLASSES
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $html$1 = document.querySelector('html');
    function resizeClassChanger() {
        $html$1.classList.remove('resp-sm');
        $html$1.classList.remove('resp-md');
        $html$1.classList.remove('resp-lg');
        if (viewportDimensions().width < 700) {
            $html$1.classList.add('resp-sm');
        } else if (viewportDimensions().width < 1024) {
            $html$1.classList.add('resp-md');
        } else {
            $html$1.classList.add('resp-lg');
        }
    }
    resizeClassChanger();
    window.addEventListener('resize', _.debounce(resizeClassChanger, 150));

    var transitionTimer;
    window.addEventListener('resize', function () {
        $html$1.classList.add('no-transitions');
        transitionTimer = setTimeout(function () {
            clearTimeout(transitionTimer);
            $html$1.classList.remove('no-transitions');
        }, 1500);
    });

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * STICKY HEADER JAVASCRIPT
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var lastScrollTop = 0;
    var delta = 5;
    var $header = document.querySelector('.header');
    var headerHeight = $header.clientHeight;

    window.addEventListener(
        'scroll',
        _.throttle(function () {
            var scrollTop = window.pageYOffset;
            // make sure they scroll more than delta
            if (Math.abs(lastScrollTop - scrollTop) <= delta + headerHeight) {
                return;
            }
            if (scrollTop > lastScrollTop && scrollTop > headerHeight) {
                var $openMenu = document.querySelector(
                    '.menus .menu > [aria-expanded="true"]'
                );
                // only hide the menu if something is not open
                if (!$openMenu) {
                    $html$1.classList.add('header-up'); // scroll down
                }
            } else {
                $html$1.classList.remove('header-up'); // scroll up
            }
            lastScrollTop = scrollTop;
        }, 100)
    );
    window.addEventListener('resize', function () {
        return (headerHeight = $header.clientHeight);
    });

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * RESPONSIVE UTILITY LINKS JAVASCRIPT
     * Moves the DOM around at large size
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $menus = $header.querySelector('.menus');
    var $topNav = $header.querySelector('nav.top');
    var $links = document.querySelector('.utility-links');
    function responsiveUtilityLinks() {
        var isLargeView = viewportDimensions().width >= 1024;
        var $nextElement = isLargeView
            ? $topNav.nextElementSibling
            : $menus.nextElementSibling;
        if ($nextElement === $links) {
            if (isLargeView) {
                // move it up
                $menus.insertAdjacentElement('afterend', $links);
            } else {
                // move it back
                $topNav.insertAdjacentElement('afterend', $links);
            }
        }
    }
    responsiveUtilityLinks();
    window.addEventListener('resize', function () {
        return responsiveUtilityLinks();
    });

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * RESPONSIVE HEADER JAVASCRIPT
     * main navigation toggles on `click` medium and small, but not large
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $mainMenuIcon = document.querySelector('.header .main-menu > .icon');
    var $mainMenuDropdown = document.querySelector('.header .dropdown-menu');
    function responsiveHeaderDropdown() {
        if (viewportDimensions().width >= 1024) {
            var haspopup = $mainMenuIcon.getAttribute('aria-haspopup');
            var expanded = $mainMenuIcon.getAttribute('aria-expanded');
            var hidden = $mainMenuDropdown.getAttribute('aria-hidden');
            if (haspopup && expanded && hidden) {
                $mainMenuIcon.setAttribute('temp-haspopup', haspopup);
                $mainMenuIcon.setAttribute('temp-expanded', expanded);
                $mainMenuDropdown.setAttribute('temp-hidden', hidden);
            }
            $mainMenuIcon.removeAttribute('aria-haspopup');
            $mainMenuIcon.removeAttribute('aria-expanded');
            $mainMenuDropdown.removeAttribute('aria-hidden');
            $mainMenuDropdown.classList.remove('visibility-hidden');
        } else if ($mainMenuDropdown.classList.contains('visibility-hidden')) {
            var haspopup$1 = $mainMenuIcon.getAttribute('temp-haspopup');
            var expanded$1 = $mainMenuIcon.getAttribute('temp-expanded');
            var hidden$1 = $mainMenuDropdown.getAttribute('temp-hidden');
            if (haspopup$1 && expanded$1 && hidden$1) {
                $mainMenuIcon.setAttribute('aria-haspopup', haspopup$1);
                $mainMenuIcon.setAttribute('aria-expanded', expanded$1);
                $mainMenuDropdown.setAttribute('aria-hidden', hidden$1);
            }
            $mainMenuIcon.removeAttribute('temp-haspopup');
            $mainMenuIcon.removeAttribute('temp-expanded');
            $mainMenuDropdown.removeAttribute('temp-hidden');
            $mainMenuDropdown.classList.add('visibility-hidden');
        }
    }
    responsiveHeaderDropdown();
    window.addEventListener('resize', function () {
        responsiveHeaderDropdown();
    });

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * RESPONSIVE HEADER JAVASCRIPT
     * plus/minus main navigation on medium and small
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $$mainMenuToggles = document.querySelectorAll('.dropdown-menu .toggle');
    _.each($$mainMenuToggles, function ($toggle) {
        $toggle.addEventListener('click', function () {
            var $section = $toggle.closest('.section');
            var $content = $section.querySelector('.content');
            var expanded = $toggle.getAttribute('aria-expanded') === 'true';
            $toggle.setAttribute('aria-expanded', !expanded);
            $section.dataset.expanded = !expanded;
            $content.classList[expanded ? 'add' : 'remove'](
                'visibility-hidden'
            );
        });
    });

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * RESPONSIVE HEADER JAVASCRIPT
     * focus main navigation on large
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $dropdownMenuNav = document.querySelector('.dropdown-menu-nav');
    var $$mainMenuSections = $dropdownMenuNav.querySelectorAll('.section');
    var $$mainMenuTitles = $dropdownMenuNav.querySelectorAll('.title a');
    var $$mainMenuUls = $dropdownMenuNav.querySelectorAll('.content');
    /*function responsiveHeaderSections() {
    const isLargeView = viewportDimensions().width >= 1024
    if (isLargeView) {
      // using jQuery for convenience here
      $('body').on('focus.dropdown-menu-nav', '*', mainNavCheckMouseOut)
    } else {
      // using jQuery for convenience here
      $('body').off('focus.dropdown-menu-nav', '*', mainNavCheckMouseOut)
    }
    _.each($$mainMenuTitles, $title => {
      const $section = $title.closest('.section')
      const $toggle = $section.querySelector('.toggle')
      const $ul = $section.querySelector('.content')
      if (isLargeView) {
        const haspopup = $toggle.getAttribute('temp-haspopup')
        if (haspopup) {
          $toggle.setAttribute('aria-haspopup', haspopup)
        }
        $toggle.removeAttribute('temp-haspopup')
        $toggle.setAttribute('aria-expanded', 'false')
        $section.dataset.expanded = 'false'
        $ul.classList.remove('visibility-hidden')
        document.addEventListener('click', closeMainMenuSections)
      } else if ($mainMenuDropdown.classList.contains('visibility-hidden')) {
        const haspopup = $toggle.getAttribute('aria-haspopup')
        if (haspopup) {
          $toggle.setAttribute('temp-haspopup', haspopup)
        }
        $section.removeAttribute('aria-haspopup')
        $ul.classList.add('visibility-hidden')
        document.removeEventListener('click', closeMainMenuSections)
      }
    })
  }
  responsiveHeaderSections()
  window.addEventListener('resize', () => responsiveHeaderSections())*/

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Main & Search Navigation
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $menuToggle = document.querySelector('.header .main-menu > button');
    var $menuDropdown = document.querySelector('.header .dropdown-menu');
    var $searchToggle = document.querySelector('.header .search > button');
    var $searchDropdown = document.querySelector('.header .dropdown-search');
    function menuItemToggle(menuClass, $toggle, $dropdown) {
        return function () {
            var expanded = $toggle.getAttribute('aria-expanded') === 'true';
            if (expanded) {
                // it is open, so close it
                $html$1.classList.remove('menu-item-open');
                $html$1.classList.remove(menuClass);
                $dropdown.setAttribute('aria-hidden', 'true');
                $toggle.setAttribute('aria-expanded', !expanded);
                $dropdown.classList.add('visibility-hidden');
            } else {
                if ($html$1.classList.contains('menu-item-open')) {
                    // resetting everything
                    $html$1.classList.remove('menu-main-open');
                    $html$1.classList.remove('menu-search-open');
                    $menuToggle.setAttribute('aria-expanded', 'false');
                    $searchToggle.setAttribute('aria-expanded', 'false');
                    $menuDropdown.setAttribute('aria-hidden', 'true');
                    $searchDropdown.setAttribute('aria-hidden', 'true');
                    $menuDropdown.classList.add('visibility-hidden');
                    $searchDropdown.classList.add('visibility-hidden');
                    // now open the menu
                    $html$1.classList.add(menuClass);
                    $dropdown.removeAttribute('aria-hidden');
                    $toggle.setAttribute('aria-expanded', !expanded);
                    $dropdown.classList.remove('visibility-hidden');
                } else {
                    // it is not open elsewhere, so open it
                    $html$1.classList.add('menu-item-open');
                    $html$1.classList.add(menuClass);
                    $dropdown.removeAttribute('aria-hidden');
                    $toggle.setAttribute('aria-expanded', !expanded);
                    $dropdown.classList.remove('visibility-hidden');
                }
                if (menuClass === 'menu-search-open') {
                    $dropdown.querySelector('input').focus();
                }
            }
        };
    }
    $menuToggle.addEventListener(
        'click',
        menuItemToggle('menu-main-open', $menuToggle, $menuDropdown)
    );
    $searchToggle.addEventListener(
        'click',
        menuItemToggle('menu-search-open', $searchToggle, $searchDropdown)
    );

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Accessibility tab loops for main menu
     * (both forward and backward loops)
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var isMediumOrSmallerView = viewportDimensions().width < 1024;
    window.addEventListener('resize', function () {
        return (isMediumOrSmallerView = viewportDimensions().width < 1024);
    });

    var $menuFocusFirst = document.querySelector('#menu-focus-first');
    var $menuFocusLast = document.querySelector('#menu-focus-last');
    $menuFocusLast.addEventListener('keydown', function (event) {
        if (
            isMediumOrSmallerView &&
            !event.shiftKey &&
            event.keyCode === 9 &&
            !$menuDropdown.classList.contains('visibility-hidden')
        ) {
            event.preventDefault();
            $menuFocusFirst.focus();
        }
    });
    $menuFocusFirst.addEventListener('keydown', function (event) {
        if (
            isMediumOrSmallerView &&
            event.shiftKey &&
            event.keyCode === 9 &&
            !$menuDropdown.classList.contains('visibility-hidden')
        ) {
            event.preventDefault();
            $menuFocusLast.focus();
        }
    });

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Tabs
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
    var $$tabs = document.querySelectorAll('.tabs button');
    _.each($$tabs, function ($tab) {
        $tab.addEventListener('click', function (event) {
            var $thisTabBlock = event.target.closest('.tab-block');
            var tabId = event.target.dataset.tabsTarget;
            tabsSetAllInactive($thisTabBlock);
            tabsSetActiveTab($thisTabBlock, tabId);
        });
    });

    function tabsSetAllInactive($tabBlock) {
        var $$tabs = $tabBlock.querySelectorAll('.tabs-title');
        _.each($$tabs, function ($tab) {
            $tab.classList.remove('is-active');
            $tab.querySelectorAll('button')[0].removeAttribute('aria-selected');
        });

        var $$tabsPanels = $tabBlock.querySelectorAll('.tabs-panel');
        _.each($$tabsPanels, function ($tabPanel) {
            $tabPanel.classList.remove('is-active');
        });
    }

    function tabsSetActiveTab($tabBlock, tabId) {
        var $activeTab = $tabBlock.querySelectorAll(
            '[data-tabs-target="' + tabId + '"]'
        )[0];
        $activeTab.setAttribute('aria-selected', true);
        $activeTab.closest('.tabs-title').classList.add('is-active');
        $tabBlock
            .querySelectorAll('[data-tab="' + tabId + '"]')[0]
            .classList.add('is-active');
    }

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * "Resources For" Responsive Dropdown
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $$subUtilityNavs = document.querySelectorAll('.sub-utility');
    var $$subUtilityToggles = document.querySelectorAll('.sub-utility .toggle');
    function closeUtilityLinks(event) {
        if (!event.target.closest('.sub-utility')) {
            _.each($$subUtilityNavs, function ($nav) {
                return ($nav.dataset.expanded = 'false');
            });
            _.each($$subUtilityToggles, function ($nav) {
                return $nav.setAttribute('aria-expanded', 'false');
            });
        }
    }
    function responsiveResourcesFor() {
        var isLarge = viewportDimensions().width >= 1024;
        _.each($$subUtilityNavs, function ($nav) {
            var $toggle = $nav.querySelector('.toggle');
            if (isLarge) {
                var expanded = $toggle.getAttribute('temp-expanded');
                if (expanded) {
                    $nav.dataset.expanded = expanded;
                    $toggle.setAttribute('aria-expanded', expanded);
                }
                $toggle.removeAttribute('temp-expanded');
                document.addEventListener('click', closeUtilityLinks);
            } else {
                var expanded$1 = $toggle.getAttribute('aria-expanded');
                if (expanded$1) {
                    $toggle.setAttribute('temp-expanded', expanded$1);
                }
                $nav.removeAttribute('data-expanded');
                $toggle.removeAttribute('aria-expanded');
                document.removeEventListener('click', closeUtilityLinks);
            }
        });
    }
    responsiveResourcesFor();
    window.addEventListener('resize', function () {
        return responsiveResourcesFor();
    });

    _.each($$subUtilityToggles, function ($toggle) {
        var $nav = $toggle.closest('.sub-utility');
        $toggle.addEventListener('click', function () {
            var expanded = $toggle.getAttribute('aria-expanded') === 'true';
            $nav.dataset.expanded = !expanded;
            $toggle.setAttribute('aria-expanded', !expanded);
        });
    });

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Sub Navigation
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $subNavToggle = document.querySelector('.nav-sub-bar .main-toggle');
    if ($subNavToggle) {
        var $subNavDropdown = document.querySelector('.nav-sub-bar .dropdown');
        $subNavToggle.addEventListener('click', function () {
            var expanded =
                $subNavToggle.getAttribute('aria-expanded') === 'true';
            if (expanded) {
                $subNavDropdown.setAttribute('aria-hidden', 'true');
                $subNavDropdown.classList.add('visibility-hidden');
            } else {
                $subNavDropdown.removeAttribute('aria-hidden');
                $subNavDropdown.classList.remove('visibility-hidden');
            }
            $subNavToggle.setAttribute('aria-expanded', !expanded);
        });
        var $subNav = document.querySelector('.nav-sub');
        document.addEventListener('click', function (event) {
            if (!$subNav.contains(event.target)) {
                $subNavDropdown.setAttribute('aria-hidden', 'true');
                $subNavToggle.setAttribute('aria-expanded', 'false');
                $subNavDropdown.classList.add('visibility-hidden');
            }
        });
        // toggling on each section
        var $$toggles = document.querySelectorAll(
            '.nav-sub .dropdown [aria-controls]'
        );
        _.each($$toggles, function ($toggle) {
            $toggle.addEventListener('click', function () {
                var $li = $toggle.closest('li');
                var expanded = $toggle.getAttribute('aria-expanded') === 'true';
                $toggle.setAttribute('aria-expanded', !expanded);
                $li.dataset.expanded = !expanded;
            });
        });
    }

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * RESPONSIVE FOOTER JAVASCRIPT
     * the use case is here for changing functionality
     * at different responsive dimensions to
     * match CSS responsive dimensions
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    var $$footerGroups = document.querySelectorAll('.footer-nav .group');
    function responsiveFooter() {
        var isSmall = viewportDimensions().width < 700;
        _.each($$footerGroups, function ($group) {
            var $toggle = $group.querySelector('.toggle');
            if (isSmall) {
                var expanded = $toggle.getAttribute('temp-expanded');
                if (expanded) {
                    $group.dataset.expanded = expanded;
                    $toggle.setAttribute('aria-expanded', expanded);
                }
                $toggle.removeAttribute('temp-expanded');
            } else {
                var expanded$1 = $toggle.getAttribute('aria-expanded');
                if (expanded$1) {
                    $toggle.setAttribute('temp-expanded', expanded$1);
                }
                $group.removeAttribute('data-expanded');
                $toggle.removeAttribute('aria-expanded');
            }
        });
    }
    responsiveFooter();
    window.addEventListener('resize', function () {
        return responsiveFooter();
    });

    // toggling on each section
    var $$footerToggles = document.querySelectorAll('.footer-nav .toggle');
    _.each($$footerToggles, function ($toggle) {
        $toggle.addEventListener('click', function () {
            var $group = $toggle.closest('.group');
            var expanded = $toggle.getAttribute('aria-expanded') === 'true';
            $toggle.setAttribute('aria-expanded', !expanded);
            $group.dataset.expanded = !expanded;
        });
    });

    // /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    //  * Responsive tables NO LONGER USING IN FAVOR OF FOUNDATION
    // *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    // $('table.table').basictable({
    // 	breakpoint: 700,
    // })

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Jump to top of page button in footer
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/

    document
        .querySelector('#back-to-top-footer')
        .addEventListener('click', function (event) {
            event.preventDefault();
            window.scroll(0, 0);
            document.body.focus();
        });

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Auto Close Inside AAMU on last item
     * When pressing tab on the last item in the menu, the menu closes.
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
    var insideAamuItems = document.querySelectorAll(
        '.sub-utility > ul > li:last-of-type a'
    );

    for (var i = 0; i < insideAamuItems.length; i++) {
        insideAamuItems[i].addEventListener('keydown', function (event) {
            var sibl = event.target.previousElementSibling;
            var attrVal = null;

            if (sibl) {
                attrVal =
                    event.target.previousElementSibling.getAttribute(
                        'aria-expanded'
                    );
                attrVal = attrVal === 'true';
            }

            if (!attrVal || attrVal == null) {
                if (event.keyCode === 9 && !event.shiftKey) {
                    document.querySelector('.sub-utility .toggle').click();
                }
            }
        });
    }

    /** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
     * Auto Close Section Navigation on last item
     * When pressing tab on the last item in the menu, the menu closes.
     *** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
    var lastItems = document.querySelectorAll(
        '.nav-sub-bar .dropdown > ul > li:last-of-type a'
    );

    for (var i = 0; i < lastItems.length; i++) {
        lastItems[i].addEventListener('keydown', function (event) {
            var sibl = event.target.previousElementSibling;
            var attrVal = null;

            if (sibl) {
                attrVal =
                    event.target.previousElementSibling.getAttribute(
                        'aria-expanded'
                    );
                attrVal = attrVal === 'true';
            }

            if (!attrVal || attrVal == null) {
                if (event.keyCode === 9 && !event.shiftKey) {
                    document.querySelector('.nav-sub .main-toggle').click();
                }
            }
        });
    }

    const searchInput = document.querySelector('input[type=search]');
    const searchToggleBttn = document.querySelector('#menu-focus-last');

    function toggleSearchBttnStateText() {
        if (searchToggleBttn.getAttribute('aria-expanded') == 'true') {
            searchToggleBttn.querySelector('span').innerHTML = 'Close Search';
        } else {
            searchToggleBttn.querySelector('span').innerHTML = 'Open Search';
        }
    }

    document.onload = toggleSearchBttnStateText();

    searchInput.addEventListener('keydown', function (e) {
        if (e.keyCode === 9 && e.shiftKey) {
            searchToggleBttn.click();
        }
    });

    searchToggleBttn.addEventListener('keydown', function (e) {
        if (e.keyCode === 9 && !e.shiftKey) {
            var attrVal = e.target.getAttribute('aria-expanded');
            attrVal = attrVal === 'true';
            console.log(attrVal);

            if (attrVal) {
                searchToggleBttn.click();
            }
        }
    });

    searchToggleBttn.addEventListener('click', function (e) {
        toggleSearchBttnStateText();
        searchInput.focus();
    });
})();
//# sourceMappingURL=app.js.map