var w001_index_header_40 = {};


// 判断是否放得下
w001_index_header_40.nav = {
    change(el){
        if(el.hasClass('hide-active')){
            $('.w001_index_header_40').addClass('pc_app')
        }else{
            $('.w001_index_header_40').removeClass('pc_app')
        }
    }
};

w001_index_header_40.search = {
    show(el){
        ly2.popup2.show(el, '/search-popup', {}, {
            callback(res){
                console.log(res)
            }
        })
    },
};

var lyuiheader_nav_001 = {};
// 判断导航是否放得下
lyuiheader_nav_001.nav_width = {
    compare(el){
        let nav_width = 0;
        let auto_width = $(el).width();
        $(el).find('.lyuiheader_nav_001-li').each(function(){
            nav_width += $(this).outerWidth()
        })
        if(nav_width > auto_width || window.innerWidth < 800){
            $(el).addClass('hide-active')
        }else{
            $(el).removeClass('hide-active')
        }
    },
    go(){
        let _thi = this;
        $('.lyuiheader_nav_001').each(function(e){
            _thi.compare(this);
        });
    }
};
$$My.setTime(()=>{lyuiheader_nav_001.nav_width.go()}, 10);;

;

;

;

$(function(){})

$(document).ready(function(){});

;

$(function(){

});

;

;

;

var temp_d_jsf_ly003_272_scroll = {
    go(){
        if($(window).width()>750){
            var pEl = $('#temp_d_jsf_ly003_272'),
                sEl = $('#temp_d_jsf_ly003_272 .list'),
                lEl = $('#temp_d_jsf_ly003_272 .list .li'),
                top = pEl[0].getBoundingClientRect().top,
                WH = $(window).height(),
                WW = $(window).width(),
                lNum = lEl.size(), //.li元素个数
                py = top - WH / lNum;
            if(py>0) py = 0;
            if($(WW <= 750)) lNum = lNum + 1;
            pEl.css({height:(lEl.width() * lNum) - (WH / lNum)});
            sEl.css({transform:'translateX('+py+'px)'});
        }
    }
}
temp_d_jsf_ly003_272_scroll.go();
$(window).on('scroll', function(){
    temp_d_jsf_ly003_272_scroll.go();
});;

;

// 定义 temp_d_ly_ly00005_149 对象，并将 AntiShake 函数放入其中
var temp_d_ly_ly00005_149 = {
    AntiShake: function(fn, wait) {
        var timer = null;
        return function() {
            if (timer !== null) {
                clearTimeout(timer);
            }
            timer = setTimeout(fn, wait);
        };
    }
};

$(window).on('scroll', temp_d_ly_ly00005_149.AntiShake(onScroll, 5));

function onScroll(){
    if($('#temp_d_ly_ly00005_149').length > 0){
        var scrollTop = $(window).scrollTop();
        var top = $('#temp_d_ly_ly00005_149').offset().top;
        if(scrollTop > top){
            if(scrollTop + $(window).height() > top + $('#temp_d_ly_ly00005_149').outerHeight() + ($(window).height() - $('.aboutHistoryBg').outerHeight())){
                $('.aboutHistoryBg').css({'position':'absolute', 'top':'inherit', 'bottom': '0px'});
            } else {
                $('.aboutHistoryBg').css({'position':'fixed', 'top': '120px', 'bottom': 'auto'});
            }
        } else {
            $('.aboutHistoryBg').css({'position':'absolute'});
        }
    }
}
onScroll();



// 引用js
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global.scrollama = factory());
}(this, (function () { 'use strict';

/**
 * Copyright 2016 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

(function(window, document) {
'use strict';


// Exits early if all IntersectionObserver and IntersectionObserverEntry
// features are natively supported.
if ('IntersectionObserver' in window &&
    'IntersectionObserverEntry' in window &&
    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {

  // Minimal polyfill for Edge 15's lack of `isIntersecting`
  // See: https://github.com/WICG/IntersectionObserver/issues/211
    if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {
        Object.defineProperty(window.IntersectionObserverEntry.prototype,
        'isIntersecting', {
        get: function () {
            return this.intersectionRatio > 0;
        }
        });
    }
    return;
    }


    /**
     * An IntersectionObserver registry. This registry exists to hold a strong
     * reference to IntersectionObserver instances currently observering a target
     * element. Without this registry, instances without another reference may be
     * garbage collected.
     */
    var registry = [];


    /**
     * Creates the global IntersectionObserverEntry constructor.
     * https://wicg.github.io/IntersectionObserver/#intersection-observer-entry
     * @param {Object} entry A dictionary of instance properties.
     * @constructor
     */
    function IntersectionObserverEntry(entry) {
    this.time = entry.time;
    this.target = entry.target;
    this.rootBounds = entry.rootBounds;
    this.boundingClientRect = entry.boundingClientRect;
    this.intersectionRect = entry.intersectionRect || getEmptyRect();
    this.isIntersecting = !!entry.intersectionRect;

    // Calculates the intersection ratio.
    var targetRect = this.boundingClientRect;
    var targetArea = targetRect.width * targetRect.height;
    var intersectionRect = this.intersectionRect;
    var intersectionArea = intersectionRect.width * intersectionRect.height;

    // Sets intersection ratio.
    if (targetArea) {
        this.intersectionRatio = intersectionArea / targetArea;
    } else {
        // If area is zero and is intersecting, sets to 1, otherwise to 0
        this.intersectionRatio = this.isIntersecting ? 1 : 0;
    }
    }


    /**
     * Creates the global IntersectionObserver constructor.
     * https://wicg.github.io/IntersectionObserver/#intersection-observer-interface
     * @param {Function} callback The function to be invoked after intersection
     *     changes have queued. The function is not invoked if the queue has
     *     been emptied by calling the `takeRecords` method.
     * @param {Object=} opt_options Optional configuration options.
     * @constructor
     */
    function IntersectionObserver(callback, opt_options) {

    var options = opt_options || {};

    if (typeof callback != 'function') {
        throw new Error('callback must be a function');
    }

    if (options.root && options.root.nodeType != 1) {
        throw new Error('root must be an Element');
    }

    // Binds and throttles `this._checkForIntersections`.
    this._checkForIntersections = throttle(
        this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);

    // Private properties.
    this._callback = callback;
    this._observationTargets = [];
    this._queuedEntries = [];
    this._rootMarginValues = this._parseRootMargin(options.rootMargin);

    // Public properties.
    this.thresholds = this._initThresholds(options.threshold);
    this.root = options.root || null;
    this.rootMargin = this._rootMarginValues.map(function(margin) {
        return margin.value + margin.unit;
    }).join(' ');
    }


    /**
     * The minimum interval within which the document will be checked for
     * intersection changes.
     */
    IntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;


    /**
     * The frequency in which the polyfill polls for intersection changes.
     * this can be updated on a per instance basis and must be set prior to
     * calling `observe` on the first target.
     */
    IntersectionObserver.prototype.POLL_INTERVAL = null;


    /**
     * Starts observing a target element for intersection changes based on
     * the thresholds values.
     * @param {Element} target The DOM element to observe.
     */
    IntersectionObserver.prototype.observe = function(target) {
    // If the target is already being observed, do nothing.
    if (this._observationTargets.some(function(item) {
        return item.element == target;
    })) {
        return;
    }

    if (!(target && target.nodeType == 1)) {
        throw new Error('target must be an Element');
    }

    this._registerInstance();
    this._observationTargets.push({element: target, entry: null});
    this._monitorIntersections();
    this._checkForIntersections();
    };


    /**
     * Stops observing a target element for intersection changes.
     * @param {Element} target The DOM element to observe.
     */
    IntersectionObserver.prototype.unobserve = function(target) {
    this._observationTargets =
        this._observationTargets.filter(function(item) {

        return item.element != target;
    });
    if (!this._observationTargets.length) {
        this._unmonitorIntersections();
        this._unregisterInstance();
    }
    };


    /**
     * Stops observing all target elements for intersection changes.
     */
    IntersectionObserver.prototype.disconnect = function() {
    this._observationTargets = [];
    this._unmonitorIntersections();
    this._unregisterInstance();
    };


    /**
     * Returns any queue entries that have not yet been reported to the
     * callback and clears the queue. This can be used in conjunction with the
     * callback to obtain the absolute most up-to-date intersection information.
     * @return {Array} The currently queued entries.
     */
    IntersectionObserver.prototype.takeRecords = function() {
    var records = this._queuedEntries.slice();
    this._queuedEntries = [];
    return records;
    };


    /**
     * Accepts the threshold value from the user configuration object and
     * returns a sorted array of unique threshold values. If a value is not
     * between 0 and 1 and error is thrown.
     * @private
     * @param {Array|number=} opt_threshold An optional threshold value or
     *     a list of threshold values, defaulting to [0].
     * @return {Array} A sorted list of unique and valid threshold values.
     */
    IntersectionObserver.prototype._initThresholds = function(opt_threshold) {
    var threshold = opt_threshold || [0];
    if (!Array.isArray(threshold)) { threshold = [threshold]; }

    return threshold.sort().filter(function(t, i, a) {
        if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {
        throw new Error('threshold must be a number between 0 and 1 inclusively');
        }
        return t !== a[i - 1];
    });
    };


    /**
     * Accepts the rootMargin value from the user configuration object
     * and returns an array of the four margin values as an object containing
     * the value and unit properties. If any of the values are not properly
     * formatted or use a unit other than px or %, and error is thrown.
     * @private
     * @param {string=} opt_rootMargin An optional rootMargin value,
     *     defaulting to '0px'.
     * @return {Array<Object>} An array of margin objects with the keys
     *     value and unit.
     */
    IntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {
    var marginString = opt_rootMargin || '0px';
    var margins = marginString.split(/\s+/).map(function(margin) {
        var parts = /^(-?\d*\.?\d+)(px|%)$/.exec(margin);
        if (!parts) {
        throw new Error('rootMargin must be specified in pixels or percent');
        }
        return {value: parseFloat(parts[1]), unit: parts[2]};
    });

    // Handles shorthand.
    margins[1] = margins[1] || margins[0];
    margins[2] = margins[2] || margins[0];
    margins[3] = margins[3] || margins[1];

    return margins;
    };


    /**
     * Starts polling for intersection changes if the polling is not already
     * happening, and if the page's visibilty state is visible.
     * @private
     */
    IntersectionObserver.prototype._monitorIntersections = function() {
    if (!this._monitoringIntersections) {
        this._monitoringIntersections = true;

        // If a poll interval is set, use polling instead of listening to
        // resize and scroll events or DOM mutations.
        if (this.POLL_INTERVAL) {
        this._monitoringInterval = setInterval(
            this._checkForIntersections, this.POLL_INTERVAL);
        }
        else {
        addEvent(window, 'resize', this._checkForIntersections, true);
        addEvent(document, 'scroll', this._checkForIntersections, true);

        if ('MutationObserver' in window) {
            this._domObserver = new MutationObserver(this._checkForIntersections);
            this._domObserver.observe(document, {
            attributes: true,
            childList: true,
            characterData: true,
            subtree: true
            });
        }
        }
    }
    };


    /**
     * Stops polling for intersection changes.
     * @private
     */
    IntersectionObserver.prototype._unmonitorIntersections = function() {
    if (this._monitoringIntersections) {
        this._monitoringIntersections = false;

        clearInterval(this._monitoringInterval);
        this._monitoringInterval = null;

        removeEvent(window, 'resize', this._checkForIntersections, true);
        removeEvent(document, 'scroll', this._checkForIntersections, true);

        if (this._domObserver) {
        this._domObserver.disconnect();
        this._domObserver = null;
        }
    }
    };


    /**
     * Scans each observation target for intersection changes and adds them
     * to the internal entries queue. If new entries are found, it
     * schedules the callback to be invoked.
     * @private
     */
    IntersectionObserver.prototype._checkForIntersections = function() {
    var rootIsInDom = this._rootIsInDom();
    var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();

    this._observationTargets.forEach(function(item) {
        var target = item.element;
        var targetRect = getBoundingClientRect(target);
        var rootContainsTarget = this._rootContainsTarget(target);
        var oldEntry = item.entry;
        var intersectionRect = rootIsInDom && rootContainsTarget &&
            this._computeTargetAndRootIntersection(target, rootRect);

        var newEntry = item.entry = new IntersectionObserverEntry({
        time: now(),
        target: target,
        boundingClientRect: targetRect,
        rootBounds: rootRect,
        intersectionRect: intersectionRect
        });

        if (!oldEntry) {
        this._queuedEntries.push(newEntry);
        } else if (rootIsInDom && rootContainsTarget) {
        // If the new entry intersection ratio has crossed any of the
        // thresholds, add a new entry.
        if (this._hasCrossedThreshold(oldEntry, newEntry)) {
            this._queuedEntries.push(newEntry);
        }
        } else {
        // If the root is not in the DOM or target is not contained within
        // root but the previous entry for this target had an intersection,
        // add a new record indicating removal.
        if (oldEntry && oldEntry.isIntersecting) {
            this._queuedEntries.push(newEntry);
        }
        }
    }, this);

    if (this._queuedEntries.length) {
        this._callback(this.takeRecords(), this);
    }
    };


    /**
     * Accepts a target and root rect computes the intersection between then
     * following the algorithm in the spec.
     * TODO(philipwalton): at this time clip-path is not considered.
     * https://wicg.github.io/IntersectionObserver/#calculate-intersection-rect-algo
     * @param {Element} target The target DOM element
     * @param {Object} rootRect The bounding rect of the root after being
     *     expanded by the rootMargin value.
     * @return {?Object} The final intersection rect object or undefined if no
     *     intersection is found.
     * @private
     */
    IntersectionObserver.prototype._computeTargetAndRootIntersection =
        function(target, rootRect) {
    var this$1 = this;


    // If the element isn't displayed, an intersection can't happen.
    if (window.getComputedStyle(target).display == 'none') { return; }

    var targetRect = getBoundingClientRect(target);
    var intersectionRect = targetRect;
    var parent = getParentNode(target);
    var atRoot = false;

    while (!atRoot) {
        var parentRect = null;
        var parentComputedStyle = parent.nodeType == 1 ?
            window.getComputedStyle(parent) : {};

        // If the parent isn't displayed, an intersection can't happen.
        if (parentComputedStyle.display == 'none') { return; }

        if (parent == this$1.root || parent == document) {
        atRoot = true;
        parentRect = rootRect;
        } else {
        // If the element has a non-visible overflow, and it's not the <body>
        // or <html> element, update the intersection rect.
        // Note: <body> and <html> cannot be clipped to a rect that's not also
        // the document rect, so no need to compute a new intersection.
        if (parent != document.body &&
            parent != document.documentElement &&
            parentComputedStyle.overflow != 'visible') {
            parentRect = getBoundingClientRect(parent);
        }
        }

        // If either of the above conditionals set a new parentRect,
        // calculate new intersection data.
        if (parentRect) {
        intersectionRect = computeRectIntersection(parentRect, intersectionRect);

        if (!intersectionRect) { break; }
        }
        parent = getParentNode(parent);
    }
    return intersectionRect;
    };


    /**
     * Returns the root rect after being expanded by the rootMargin value.
     * @return {Object} The expanded root rect.
     * @private
     */
    IntersectionObserver.prototype._getRootRect = function() {
    var rootRect;
    if (this.root) {
        rootRect = getBoundingClientRect(this.root);
    } else {
        // Use <html>/<body> instead of window since scroll bars affect size.
        var html = document.documentElement;
        var body = document.body;
        rootRect = {
        top: 0,
        left: 0,
        right: html.clientWidth || body.clientWidth,
        width: html.clientWidth || body.clientWidth,
        bottom: html.clientHeight || body.clientHeight,
        height: html.clientHeight || body.clientHeight
        };
    }
    return this._expandRectByRootMargin(rootRect);
    };


    /**
     * Accepts a rect and expands it by the rootMargin value.
     * @param {Object} rect The rect object to expand.
     * @return {Object} The expanded rect.
     * @private
     */
    IntersectionObserver.prototype._expandRectByRootMargin = function(rect) {
    var margins = this._rootMarginValues.map(function(margin, i) {
        return margin.unit == 'px' ? margin.value :
            margin.value * (i % 2 ? rect.width : rect.height) / 100;
    });
    var newRect = {
        top: rect.top - margins[0],
        right: rect.right + margins[1],
        bottom: rect.bottom + margins[2],
        left: rect.left - margins[3]
    };
    newRect.width = newRect.right - newRect.left;
    newRect.height = newRect.bottom - newRect.top;

    return newRect;
    };


    /**
     * Accepts an old and new entry and returns true if at least one of the
     * threshold values has been crossed.
     * @param {?IntersectionObserverEntry} oldEntry The previous entry for a
     *    particular target element or null if no previous entry exists.
     * @param {IntersectionObserverEntry} newEntry The current entry for a
     *    particular target element.
     * @return {boolean} Returns true if a any threshold has been crossed.
     * @private
     */
    IntersectionObserver.prototype._hasCrossedThreshold =
        function(oldEntry, newEntry) {
    var this$1 = this;


    // To make comparing easier, an entry that has a ratio of 0
    // but does not actually intersect is given a value of -1
    var oldRatio = oldEntry && oldEntry.isIntersecting ?
        oldEntry.intersectionRatio || 0 : -1;
    var newRatio = newEntry.isIntersecting ?
        newEntry.intersectionRatio || 0 : -1;

    // Ignore unchanged ratios
    if (oldRatio === newRatio) { return; }

    for (var i = 0; i < this.thresholds.length; i++) {
        var threshold = this$1.thresholds[i];

        // Return true if an entry matches a threshold or if the new ratio
        // and the old ratio are on the opposite sides of a threshold.
        if (threshold == oldRatio || threshold == newRatio ||
            threshold < oldRatio !== threshold < newRatio) {
        return true;
        }
    }
    };


    /**
     * Returns whether or not the root element is an element and is in the DOM.
     * @return {boolean} True if the root element is an element and is in the DOM.
     * @private
     */
    IntersectionObserver.prototype._rootIsInDom = function() {
    return !this.root || containsDeep(document, this.root);
    };


    /**
     * Returns whether or not the target element is a child of root.
     * @param {Element} target The target element to check.
     * @return {boolean} True if the target element is a child of root.
     * @private
     */
    IntersectionObserver.prototype._rootContainsTarget = function(target) {
    return containsDeep(this.root || document, target);
    };


    /**
     * Adds the instance to the global IntersectionObserver registry if it isn't
     * already present.
     * @private
     */
    IntersectionObserver.prototype._registerInstance = function() {
    if (registry.indexOf(this) < 0) {
        registry.push(this);
    }
    };


    /**
     * Removes the instance from the global IntersectionObserver registry.
     * @private
     */
    IntersectionObserver.prototype._unregisterInstance = function() {
    var index = registry.indexOf(this);
    if (index != -1) { registry.splice(index, 1); }
    };


    /**
     * Returns the result of the performance.now() method or null in browsers
     * that don't support the API.
     * @return {number} The elapsed time since the page was requested.
     */
    function now() {
    return window.performance && performance.now && performance.now();
    }


    /**
     * Throttles a function and delays its executiong, so it's only called at most
     * once within a given time period.
     * @param {Function} fn The function to throttle.
     * @param {number} timeout The amount of time that must pass before the
     *     function can be called again.
     * @return {Function} The throttled function.
     */
    function throttle(fn, timeout) {
    var timer = null;
    return function () {
        if (!timer) {
        timer = setTimeout(function() {
            fn();
            timer = null;
        }, timeout);
        }
    };
    }


    /**
     * Adds an event handler to a DOM node ensuring cross-browser compatibility.
     * @param {Node} node The DOM node to add the event handler to.
     * @param {string} event The event name.
     * @param {Function} fn The event handler to add.
     * @param {boolean} opt_useCapture Optionally adds the even to the capture
     *     phase. Note: this only works in modern browsers.
     */
    function addEvent(node, event, fn, opt_useCapture) {
    if (typeof node.addEventListener == 'function') {
        node.addEventListener(event, fn, opt_useCapture || false);
    }
    else if (typeof node.attachEvent == 'function') {
        node.attachEvent('on' + event, fn);
    }
    }


    /**
     * Removes a previously added event handler from a DOM node.
     * @param {Node} node The DOM node to remove the event handler from.
     * @param {string} event The event name.
     * @param {Function} fn The event handler to remove.
     * @param {boolean} opt_useCapture If the event handler was added with this
     *     flag set to true, it should be set to true here in order to remove it.
     */
    function removeEvent(node, event, fn, opt_useCapture) {
    if (typeof node.removeEventListener == 'function') {
        node.removeEventListener(event, fn, opt_useCapture || false);
    }
    else if (typeof node.detatchEvent == 'function') {
        node.detatchEvent('on' + event, fn);
    }
    }


    /**
     * Returns the intersection between two rect objects.
     * @param {Object} rect1 The first rect.
     * @param {Object} rect2 The second rect.
     * @return {?Object} The intersection rect or undefined if no intersection
     *     is found.
     */
    function computeRectIntersection(rect1, rect2) {
    var top = Math.max(rect1.top, rect2.top);
    var bottom = Math.min(rect1.bottom, rect2.bottom);
    var left = Math.max(rect1.left, rect2.left);
    var right = Math.min(rect1.right, rect2.right);
    var width = right - left;
    var height = bottom - top;

    return (width >= 0 && height >= 0) && {
        top: top,
        bottom: bottom,
        left: left,
        right: right,
        width: width,
        height: height
    };
    }


    /**
     * Shims the native getBoundingClientRect for compatibility with older IE.
     * @param {Element} el The element whose bounding rect to get.
     * @return {Object} The (possibly shimmed) rect of the element.
     */
    function getBoundingClientRect(el) {
    var rect;

    try {
        rect = el.getBoundingClientRect();
    } catch (err) {
        // Ignore Windows 7 IE11 "Unspecified error"
        // https://github.com/WICG/IntersectionObserver/pull/205
    }

    if (!rect) { return getEmptyRect(); }

    // Older IE
    if (!(rect.width && rect.height)) {
        rect = {
        top: rect.top,
        right: rect.right,
        bottom: rect.bottom,
        left: rect.left,
        width: rect.right - rect.left,
        height: rect.bottom - rect.top
        };
    }
    return rect;
    }


    /**
     * Returns an empty rect object. An empty rect is returned when an element
     * is not in the DOM.
     * @return {Object} The empty rect.
     */
    function getEmptyRect() {
    return {
        top: 0,
        bottom: 0,
        left: 0,
        right: 0,
        width: 0,
        height: 0
    };
    }

    /**
     * Checks to see if a parent element contains a child elemnt (including inside
     * shadow DOM).
     * @param {Node} parent The parent element.
     * @param {Node} child The child element.
     * @return {boolean} True if the parent node contains the child node.
     */
    function containsDeep(parent, child) {
    var node = child;
    while (node) {
        if (node == parent) { return true; }

        node = getParentNode(node);
    }
    return false;
    }


    /**
     * Gets the parent node of an element or its host element if the parent node
     * is a shadow root.
     * @param {Node} node The node whose parent to get.
     * @return {Node|null} The parent node or null if no parent exists.
     */
    function getParentNode(node) {
    var parent = node.parentNode;

    if (parent && parent.nodeType == 11 && parent.host) {
        // If the parent is a shadow root, return the host element.
        return parent.host;
    }
    return parent;
    }


    // Exposes the constructors globally.
    window.IntersectionObserver = IntersectionObserver;
    window.IntersectionObserverEntry = IntersectionObserverEntry;

    }(window, document));

    // DOM helper functions

    // private
    function selectionToArray(selection) {
        var len = selection.length;
        var result = [];
        for (var i = 0; i < len; i += 1) {
            result.push(selection[i]);
        }
        return result;
    }

    // public
    function select(selector) {
        return document.querySelector(selector);
    }

    function selectAll(selector, parent) {
        if ( parent === void 0 ) parent = document;

        return selectionToArray(parent.querySelectorAll(selector));
    }

    function scrollama() {
    var id = Math.floor(Math.random() * 100000);
    var ZERO_MOE = 1; // zero with some rounding margin of error
    var callback = {};
    var io = {};

    var containerEl = null;
    var graphicEl = null;
    var stepEl = null;

    var offsetVal = 0;
    var offsetMargin = 0;
    var vh = 0;
    var stepHeights = null;
    var bboxGraphic = null;

    var thresholdProgress = 0;

    var isReady = false;
    var isEnabled = false;
    var debugMode = false;
    var progressMode = false;

    // NOTIFY CALLBACKS
    function notifyStepEnter(element, direction) {
        var index = +element.getAttribute("data-scrollama-index");
        var resp = { element: element, index: index, direction: direction };
        if (callback.stepEnter && typeof callback.stepEnter === "function")
        { callback.stepEnter(resp); }
    }

    function notifyStepExit(element, direction) {
        var index = +element.getAttribute("data-scrollama-index");
        var resp = { element: element, index: index, direction: direction };
        if (callback.stepExit && typeof callback.stepExit === "function")
        { callback.stepExit(resp); }
    }

    function notifyStepProgress(element, progress) {
        var index = +element.getAttribute("data-scrollama-index");
        var resp = { element: element, index: index, progress: progress };
        if (callback.stepProgress && typeof callback.stepProgress === "function")
        { callback.stepProgress(resp); }
    }

    function notifyContainerEnter(direction) {
        var resp = { direction: direction };
        if (
        callback.containerEnter &&
        typeof callback.containerEnter === "function"
        )
        { callback.containerEnter(resp); }
    }

    function notifyContainerExit(direction) {
        var resp = { direction: direction };
        if (callback.containerExit && typeof callback.containerExit === "function")
        { callback.containerExit(resp); }
    }

    // OBSERVER - INTERSECT HANDLING

    // if TOP edge of step crosses threshold,
    // bottom must be > 0 which means it is on "screen" (shifted by offset)
    function intersectStepTop(entries) {
        entries.forEach(function (entry) {
        var isIntersecting = entry.isIntersecting;
        var boundingClientRect = entry.boundingClientRect;
        var target = entry.target;
        var bottom = boundingClientRect.bottom;
        var bottomAdjusted = bottom - offsetMargin;
        if (bottomAdjusted >= -ZERO_MOE) {
            var direction = isIntersecting ? "down" : "up";
            if (isIntersecting) { notifyStepEnter(target, direction); }
            else { notifyStepExit(target, direction); }
        }
        });
    }

    function intersectStepBottom(entries) {
        entries.forEach(function (entry) {
        var isIntersecting = entry.isIntersecting;
        var boundingClientRect = entry.boundingClientRect;
        var target = entry.target;
        var bottom = boundingClientRect.bottom;
        var height = boundingClientRect.height;
        var bottomAdjusted = bottom - offsetMargin;
        if (
            bottomAdjusted >= -ZERO_MOE &&
            bottomAdjusted < height &&
            isIntersecting
        ) {
            var direction = "up";
            notifyStepEnter(target, direction);
        } else if (bottomAdjusted <= ZERO_MOE && !isIntersecting) {
            var direction$1 = "down";
            notifyStepExit(target, direction$1);
        }
        });
    }

    function intersectStepProgress(entries) {
        entries.forEach(function (entry) {
        var isIntersecting = entry.isIntersecting;
        var intersectionRatio = entry.intersectionRatio;
        var boundingClientRect = entry.boundingClientRect;
        var target = entry.target;
        var bottom = boundingClientRect.bottom;
        var bottomAdjusted = bottom - offsetMargin;

        if (isIntersecting && bottomAdjusted >= -ZERO_MOE) {
            notifyStepProgress(target, +intersectionRatio.toFixed(3));
        }
        });
    }

    function intersectTop(entries) {
        var ref = entries[0];
        var isIntersecting = ref.isIntersecting;
        var boundingClientRect = ref.boundingClientRect;
        var bottom = boundingClientRect.bottom;
        if (bottom > -ZERO_MOE) {
        var direction = isIntersecting ? "down" : "up";
        if (isIntersecting) { notifyContainerEnter(direction); }
        else { notifyContainerExit(direction); }
        }
    }

    function intersectBottom(entries) {
        var ref = entries[0];
        var isIntersecting = ref.isIntersecting;
        var boundingClientRect = ref.boundingClientRect;
        var top = boundingClientRect.top;
        if (top < ZERO_MOE) {
        var direction = isIntersecting ? "up" : "down";
        if (isIntersecting) { notifyContainerEnter(direction); }
        else { notifyContainerExit(direction); }
        }
    }

    // OBSERVER - CREATION
    function updateTopIO() {
        if (io.top) { io.top.unobserve(containerEl); }

        var options = {
        root: null,
        rootMargin: (vh + "px 0px -" + vh + "px 0px"),
        threshold: 0
        };

        io.top = new IntersectionObserver(intersectTop, options);
        io.top.observe(containerEl);
    }

    function updateBottomIO() {
        if (io.bottom) { io.bottom.unobserve(containerEl); }
        var options = {
        root: null,
        rootMargin: ("-" + (bboxGraphic.height) + "px 0px " + (bboxGraphic.height) + "px 0px"),
        threshold: 0
        };

        io.bottom = new IntersectionObserver(intersectBottom, options);
        io.bottom.observe(containerEl);
    }

    // top edge
    function updateStepTopIO() {
        if (io.stepTop) { io.stepTop.forEach(function (d) { return d.disconnect(); }); }

        io.stepTop = stepEl.map(function (el, i) {
        var marginTop = stepHeights[i] - offsetMargin;
        var marginBottom = -vh + offsetMargin;
        var rootMargin = marginTop + "px 0px " + marginBottom + "px 0px";

        var options = {
            root: null,
            rootMargin: rootMargin,
            threshold: 0
        };

        var obs = new IntersectionObserver(intersectStepTop, options);
        obs.observe(el);
        return obs;
        });
    }

    // bottom edge
    function updateStepBottomIO() {
        if (io.stepBottom) { io.stepBottom.forEach(function (d) { return d.disconnect(); }); }

        io.stepBottom = stepEl.map(function (el, i) {
        var marginTop = -offsetMargin;
        var marginBottom = -vh + stepHeights[i] + offsetMargin;
        var rootMargin = marginTop + "px 0px " + marginBottom + "px 0px";

        var options = {
            root: null,
            rootMargin: rootMargin,
            threshold: 0
        };

        var obs = new IntersectionObserver(intersectStepBottom, options);
        obs.observe(el);
        return obs;
        });
    }

    // progress progress tracker
    function updateStepProgressIO() {
        if (io.stepProgress) { io.stepProgress.forEach(function (d) { return d.disconnect(); }); }

        io.stepProgress = stepEl.map(function (el, i) {
        var marginTop = stepHeights[i] - offsetMargin;
        var marginBottom = -vh + offsetMargin;
        var rootMargin = marginTop + "px 0px " + marginBottom + "px 0px";

        var options = {
            root: null,
            rootMargin: rootMargin,
            threshold: thresholdProgress
        };

        var obs = new IntersectionObserver(intersectStepProgress, options);
        obs.observe(el);
        return obs;
        });
    }

    function updateIO() {
        updateStepTopIO();
        updateStepBottomIO();

        if (progressMode) { updateStepProgressIO(); }

        if (containerEl && graphicEl) {
        updateTopIO();
        updateBottomIO();
        }
    }

    // HELPER FUNCTIONS
    function handleResize() {
        vh = window.innerHeight;
        bboxGraphic = graphicEl ? graphicEl.getBoundingClientRect() : null;

        offsetMargin = offsetVal * vh;

        stepHeights = stepEl
        ? stepEl.map(function (el) { return el.getBoundingClientRect().height; })
        : [];

        if (isEnabled && isReady) { updateIO(); }

        if (debugMode) {
        var debugEl = document.querySelector(("#scrollama__debug--offset-" + id));
        debugEl.style.top = offsetMargin + "px";
        }
    }

    function handleEnable(enable) {
        if (enable && !isEnabled) {
        if (isReady) { updateIO(); }
        isEnabled = true;
        } else if (!enable) {
        if (io.top) { io.top.disconnect(); }
        if (io.bottom) { io.bottom.disconnect(); }
        if (io.stepTop) { io.stepTop.forEach(function (d) { return d.disconnect(); }); }
        if (io.stepBottom) { io.stepBottom.forEach(function (d) { return d.disconnect(); }); }
        if (io.stepProgress) { io.stepProgress.forEach(function (d) { return d.disconnect(); }); }
        isEnabled = false;
        }
    }

    function indexSteps() {
        stepEl.forEach(function (el, i) { return el.setAttribute("data-scrollama-index", i); });
    }

    function addDebug() {
        if (debugMode) {
        var el = document.createElement("div");
        el.setAttribute("id", ("scrollama__debug--offset-" + id));
        el.setAttribute("class", "scrollama__debug--offset");
        el.style.position = "fixed";
        el.style.top = "0";
        el.style.left = "0";
        el.style.width = "100%";
        el.style.height = "1px";
        el.style.borderBottom = "2px dashed red";
        var text = document.createElement("p");
        var textClass = stepEl[0].getAttribute("class");
        text.innerText = "\"." + textClass + "\" trigger: " + offsetVal;
        text.style.fontSize = "12px";
        text.style.fontFamily = "monospace";
        text.style.color = "red";
        text.style.margin = "0";
        text.style.padding = "6px";
        el.appendChild(text);
        document.body.appendChild(el);
        }
    }

    function setThreshold() {
        var count = 100;
        if (progressMode) {
        thresholdProgress = [];
        var ratio = 1 / count;
        for (var i = 0; i < count; i++) {
            thresholdProgress.push(i * ratio);
        }
        }
    }

    var S = {};

    S.setup = function (ref) {
        var container = ref.container;
        var graphic = ref.graphic;
        var step = ref.step;
        var offset = ref.offset; if ( offset === void 0 ) offset = 0.5;
        var progress = ref.progress; if ( progress === void 0 ) progress = false;
        var debug = ref.debug; if ( debug === void 0 ) debug = false;

        if (step) {
        stepEl = selectAll(step);
        containerEl = container ? select(container) : null;
        graphicEl = graphic ? select(graphic) : null;
        S.offsetTrigger(offset);
        debugMode = debug;
        progressMode = progress;
        isReady = true;

        addDebug();
        indexSteps();
        setThreshold();
        handleResize();
        handleEnable(true);
        } else { console.error("scrollama error: missing step element"); }
        return S;
    };

    S.resize = function () {
        handleResize();
        return S;
    };

    S.enable = function () {
        handleEnable(true);
        return S;
    };

    S.disable = function () {
        handleEnable(false);
        return S;
    };

    S.offsetTrigger = function (x) {
        if (x && typeof !isNaN(x)) {
        offsetVal = Math.min(Math.max(0, x), 1);
        return S;
        }
        return offsetVal;
    };

    S.onStepEnter = function (cb) {
        callback.stepEnter = cb;
        return S;
    };

    S.onStepExit = function (cb) {
        callback.stepExit = cb;
        return S;
    };

    S.onStepProgress = function (cb) {
        callback.stepProgress = cb;
        return S;
    };

    S.onContainerEnter = function (cb) {
        callback.containerEnter = cb;
        return S;
    };

    S.onContainerExit = function (cb) {
        callback.containerExit = cb;
        return S;
    };

    return S;
}

return scrollama;

})));

var scroller = scrollama();
var leng = $('.aboutHistoryList .list').length;
$('.aboutHistoryList .list').eq(0).addClass('cur');
$('.yearBox .bar span').css({height: (1 / leng) * 100 +'%'});
scroller.setup({
    step: '.aboutHistoryList .list',
})
.onStepEnter(handleStepEnter);
function handleStepEnter(response) {
    var resJson = JSON.parse(JSON.stringify(response));
    $('.aboutHistoryList .list').removeClass('cur').eq(resJson.index).addClass('cur');
    $('.yearList .list').hide().eq(resJson.index).show();
    $('.yearBox .bar span').css({height: ((resJson.index + 1) / leng) * 100 +'%'});
}
window.addEventListener('resize', scroller.resize);;

;

$(function(){

});

;

;

;

;

;

;

;

;

;

;

;

;

;

$(document).on('click','#w005_index_footer_48_nav_app .dl .dt',function(){
    var parent = $(this).parent();
    if(!parent.find('.dd a').size()){return}
    if(parent.hasClass('cur')){
        parent.removeClass('cur')
    }else{
        parent.addClass('cur')
    }
    parent.find('.dd').slideToggle(500)
    parent.siblings().find('.dd').slideUp(500)
});

;