Na}{

File Content: bundle.js

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 1460);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {module.exports = global["React"] = __webpack_require__(1427);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 1 */
/***/ (function(module, exports) {

// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

}
function runClearTimeout(marker) {
    if (cachedClearTimeout === clearTimeout) {
        //normal enviroments in sane situations
        return clearTimeout(marker);
    }
    // if clearTimeout wasn't available but was latter defined
    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
        cachedClearTimeout = clearTimeout;
        return clearTimeout(marker);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedClearTimeout(marker);
    } catch (e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
        } catch (e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
        }
    }

}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = runTimeout(cleanUpNextTick);
    draining = true;

process.nextTick = function (fun) {
    var args = new Array(arguments.length - 1);
    if (arguments.length > 1) {
        for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
        }
    }
    queue.push(new Item(fun, args));
    if (queue.length === 1 && !draining) {
        runTimeout(drainQueue);
    }
};

// v8 likes predictible objects
function Item(fun, array) {
    this.fun = fun;
    this.array = array;
}
Item.prototype.run = function () {
    this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;

process.listeners = function (name) { return [] }

process.binding = function (name) {
    throw new Error('process.binding is not supported');
};

process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function($) {

var _getPrettyDate = __webpack_require__(714);

var _getPrettyDate2 = _interopRequireDefault(_getPrettyDate);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var keyPath = __webpack_require__(39),
    scrollToSelectedNode = __webpack_require__(241),
    getPathFromUrl = __webpack_require__(724),
    getScrollDistance = __webpack_require__(369),
    getPathFromPosition = __webpack_require__(239),
    getDropTargetPath = __webpack_require__(238),
    fireAjax = __webpack_require__(707),
    getShortcode = __webpack_require__(370),
    normalizePathForMultipleDelete = __webpack_require__(720),
    getPathFromSelectionState = __webpack_require__(97),
    normalizePathForMultipleDuplicate = __webpack_require__(721),
    browserHistory = __webpack_require__(40).browserHistory,
    stripOutputBeforeSave = __webpack_require__(377),
    unescapeContent = __webpack_require__(378),
    encodePath = __webpack_require__(43).encodePath,
    store = __webpack_require__(11),
    routeResolve = __webpack_require__(33),
    getHeaderFonts = __webpack_require__(713),
    addDefaultValueToInitialPageContent = __webpack_require__(373),
    getObjectType = __webpack_require__(366).default,
    changeUuid = __webpack_require__(374),
    parentComponentFinder = __webpack_require__(98),
    isJSON = __webpack_require__(371),
    parseModuleOptions = __webpack_require__(364),
    mergeWith = __webpack_require__(963),
    Immutable = __webpack_require__(3);

module.exports.setPreset = function (path, preset) {

return function (dispatch, getState) {

var moduleOptions = getState().moduleOptions,
            newPreset = preset.map(function (currentPreset) {
            return addDefaultValueToInitialPageContent(changeUuid(currentPreset), moduleOptions);
        });

dispatch({
            type: 'SET_PRESET',
            path: path,
            preset: newPreset
        });
        setTimeout(function () {
            dispatch(module.exports.setSelection(path, 'single'));
        }, 0);
    };
};

module.exports.resetPreset = function (path, preset) {

return function (dispatch, getState) {

var moduleOptions = getState().moduleOptions,
            moduleData,
            originalModule = getState().drawerController.getIn(['meta', 'module']),
            currentDrawerMeta,
            getInArray = keyPath(path, 'present', '');
        dispatch({
            type: 'RESET_PRESET',
            path: path,
            preset: preset,
            moduleOptions: moduleOptions,
            module: originalModule
        });
        moduleData = getState().tatsu_page_content.getIn(getInArray);
        currentDrawerMeta = getState().drawerController.get('meta');
        currentDrawerMeta = currentDrawerMeta.set('module', moduleData);
        dispatch(module.exports.openDrawer('preset', currentDrawerMeta));
    };
};

module.exports.duplicate = function duplicate(modulePath, name) {

return function (dispatch, getState) {
        var moduleOptions = getState().moduleOptions,
            parentModule,
            pathArray,
            parentRoute,
            parentPath,
            moduleType = moduleOptions.getIn([name, 'type']),
            isBuiltIn = moduleOptions.getIn([name, 'is_built_in']);
        if (Immutable.List.isList(modulePath.get(0))) {
            store.dispatch(module.exports.resetSelection());
            parentRoute = routeResolve(window.location.pathname);
            browserHistory.push(parentRoute + 'layoutManager/');
            modulePath = normalizePathForMultipleDuplicate(modulePath);
        }
        dispatch(module.exports.closeDrawer());
        dispatch(module.exports.closeContextMenu());
        dispatch({ type: 'DUPLICATE', path: modulePath, moduleName: name, moduleOptions: moduleOptions });
        if ('sub_module' == moduleType && !isBuiltIn) {
            parentPath = modulePath.pop();
            dispatch(module.exports.updateShortcode(parentPath));
        }
    };
};

module.exports.deleteModule = function deleteModule(modulePath, name) {

return function (dispatch, getState) {
        var moduleOptions = getState().moduleOptions,
            parentModule,
            parentPath,
            pathArray,
            moduleJson,
            moduleData,
            builderMode = getState().builderMode,
            parentRoute = routeResolve(window.location.pathname),
            serializedPath,
            moduleType = moduleOptions.getIn([name, 'type']),
            isBuiltIn = moduleOptions.getIn([name, 'is_built_in']);
        dispatch(module.exports.closeDrawer());
        dispatch(module.exports.closeContextMenu());
        if (Immutable.List.isList(modulePath.get(0))) {
            store.dispatch(module.exports.resetSelection());
            browserHistory.push(parentRoute + 'layoutManager/');
            modulePath = normalizePathForMultipleDelete(modulePath, builderMode);
        } else {
            pathArray = keyPath(modulePath.pop(), 'present', '');
            moduleData = getState().tatsu_page_content.getIn(pathArray);
            if (moduleData.get('type') !== 'multi') {
                store.dispatch(module.exports.resetSelection());
                browserHistory.push(parentRoute + 'layoutManager/');
            } else {
                store.dispatch(module.exports.setSelection(modulePath.pop(), 'single'));
            }
        }
        dispatch({ type: 'DELETE_MODULE', path: modulePath, moduleName: name, moduleOptions: moduleOptions });
        if ('sub_module' == moduleType && !isBuiltIn) {
            parentPath = modulePath.pop();
            dispatch(module.exports.updateShortcode(parentPath));
        }
    };
};

module.exports.updateShortcode = function updateShortcode(modulePath, preventSpinner) {

return function (dispatch, getState) {

var moduleData,
            pathArray,
            moduleJson,
            moduleAtts,
            moduleOptions = getState().moduleOptions,
            attsFromModuleOptions;
        if (Immutable.List.isList(modulePath.get(0))) {
            modulePath.forEach(function (curPath) {

pathArray = keyPath(curPath, 'present', '');
                moduleData = getState().tatsu_page_content.getIn(pathArray);
                if ('tatsu_header_column' == moduleData.get('name') || 'tatsu_slide_menu_column' == moduleData.get('name') || 'tatsu_column' == moduleData.get('name') || 'tatsu_inner_column' == moduleData.get('name')) {
                    curPath = curPath.push(moduleData.get('inner').size - 1);
                    pathArray = keyPath(curPath, 'present', '');
                    moduleData = getState().tatsu_page_content.getIn(pathArray);
                }
                if (!preventSpinner) {
                    dispatch({
                        type: 'SET_SPINNER',
                        path: curPath
                    });
                }

// Edit Att of type Color 
                moduleAtts = moduleData.get('atts');
                attsFromModuleOptions = moduleOptions.getIn([moduleData.get('name'), 'atts']);
                moduleData = stripOutputBeforeSave(moduleData, moduleOptions);
                moduleData = moduleData.set('shortcode_output', '');
                moduleJson = JSON.stringify(moduleData.toJSON());
                fireAjax({
                    action: 'tatsu_module',
                    module: moduleJson
                }).then(function (result) {

result = 'tatsu_text_with_shortcodes' !== moduleData.get('name') ? unescapeContent(result) : result;
                    dispatch({
                        type: 'UPDATE_SHORTCODE',
                        path: curPath,
                        shortcodeData: result
                    });
                    dispatch({
                        type: 'RESET_SPINNER',
                        path: curPath
                    });
                }).catch(function (error) {

//set error message
                    dispatch({
                        type: 'RESET_SPINNER',
                        path: curPath
                    });
                });
            });
        } else {
            pathArray = keyPath(modulePath, 'present', '');
            moduleData = getState().tatsu_page_content.getIn(pathArray);
            if ('tatsu_header_column' == moduleData.get('name') || 'tatsu_slide_menu_column' == moduleData.get('name') || 'tatsu_column' == moduleData.get('name') || 'tatsu_inner_column' == moduleData.get('name')) {
                modulePath = modulePath.push(moduleData.get('inner').size - 1);
                pathArray = keyPath(modulePath, 'present', '');
                moduleData = getState().tatsu_page_content.getIn(pathArray);
            }
            if (!preventSpinner) {
                dispatch({
                    type: 'SET_SPINNER',
                    path: modulePath
                });
            }

// Edit Att of type Color 
            moduleAtts = moduleData.get('atts');
            attsFromModuleOptions = moduleOptions.getIn([moduleData.get('name'), 'atts']);
            moduleData = stripOutputBeforeSave(moduleData, moduleOptions);
            moduleData = moduleData.set('shortcode_output', '');
            moduleJson = JSON.stringify(moduleData.toJSON());
            fireAjax({
                action: 'tatsu_module',
                module: moduleJson
            }).then(function (result) {

result = 'tatsu_text_with_shortcodes' !== moduleData.get('name') ? unescapeContent(result) : result;
                dispatch({
                    type: 'UPDATE_SHORTCODE',
                    path: modulePath,
                    shortcodeData: result
                });
                dispatch({
                    type: 'RESET_SPINNER',
                    path: modulePath
                });
            }).catch(function (error) {

//set error message
                dispatch({
                    type: 'RESET_SPINNER',
                    path: modulePath
                });
            });
        }
    };
};

module.exports.reorder = function reorder(sourcePath, targetPath) {
    return {
        type: 'REORDER',
        sourcePath: sourcePath,
        targetPath: targetPath
    };
};

module.exports.columnLayout = function columnLayout(layout, path) {

return function (dispatch, getState) {

module.exports.addToTemplate = function addToTemplate(name, title, template) {
    return {
        type: 'SAVE_AS_TEMPLATE',
        name: name,
        title: title,
        templateType: template
    };
};
module.exports.addModule = function addModule(path, moduleName, addType, position) {

return function (dispatch, getState) {
        var moduleOptions = getState().moduleOptions,
            isBuiltIn = moduleOptions.getIn([moduleName, 'is_built_in']),
            moduleType = moduleOptions.getIn([moduleName, 'type']),
            pathArray,
            currentModule,
            pathInState,
            positionInState,
            newModuleId;

if ('insert' == addType) {
            if (getState().drawerController.get('open')) {
                pathInState = getState().drawerController.getIn(['meta', 'path']);
                positionInState = getState().drawerController.getIn(['meta', 'position']);
            } else if (0 < getState().dragMonitor.get('path').size) {
                pathInState = getState().dragMonitor.get('path');
                positionInState = getState().dragMonitor.get('position');
            } else {
                pathInState = path;
                positionInState = position;
            }
            path = getPathFromPosition(pathInState, positionInState, true);
        }
        dispatch(module.exports.closeDrawer());
        if (!isBuiltIn) {
            dispatch({
                type: 'ADD_MODULE',
                path: path,
                addType: addType,
                moduleName: moduleName,
                moduleOptions: moduleOptions
            });
            dispatch(module.exports.updateShortcode(path, true));
        } else {
            dispatch({
                type: 'ADD_MODULE',
                path: path,
                addType: addType,
                moduleName: moduleName,
                moduleOptions: getState().moduleOptions
            });
        }
        currentModule = getState().tatsu_page_content.getIn(keyPath(path, 'present', ''));
        if ('push' == addType) {
            path = path.push(currentModule.get('inner').size - 1);
        }
        if (['tatsu_row', 'tatsu_section'].indexOf(moduleName) > -1) {
            var drawerMeta = Immutable.Map({
                name: 'section',
                path: path,
                module: getState().tatsu_page_content.getIn(keyPath(path, 'present', '')),
                title: 'Section'
            });
            newModuleId = getState().tatsu_page_content.getIn(keyPath(path, 'present', 'id'));
            if (moduleName === 'tatsu_section') {
                dispatch(module.exports.openDrawer('preset', drawerMeta));
            }
        }
        if ('tatsu_header_row' == moduleName) {
            var drawerMeta = Immutable.Map({
                name: 'tatsu_header_row',
                path: path,
                module: getState().tatsu_page_content.getIn(keyPath(path, 'present', '')),
                title: 'Header Row'
            });
            newModuleId = getState().tatsu_page_content.getIn(keyPath(path, 'present', 'id'));
            dispatch(module.exports.openDrawer('preset', drawerMeta));
        }

if ('push' == addType && ('sub_module' == moduleType || 'tatsu_button_group' == currentModule.get('name') || 'tatsu_icon_group' == currentModule.get('name'))) {
            setTimeout(function () {
                dispatch(module.exports.setSelection(path.pop(), 'single', true));
            }, 0);
        } else {
            setTimeout(function () {
                if (['tatsu_row', 'tatsu_section'].indexOf(moduleName) > -1) {
                    var moduleElement = document.getElementById('tatsu-preview').contentDocument.getElementsByClassName('be-pb-observer-' + newModuleId)[0];
                    if (null != moduleElement) {
                        scrollToSelectedNode(moduleElement);
                    }
                }
                if (getState().dragMonitor.get('type') !== 'birdsEyeView') {
                    dispatch(module.exports.setSelection(path, 'single', true));
                }
            }, 0);
        }
    };
};
module.exports.loadSectionPresets = function () {

return function (dispatch, getState) {

return $.ajax({
            type: 'POST',
            url: tatsuConfig.ajaxurl,
            dataType: 'json',
            data: {
                action: 'tatsu_get_concepts',
                nonce: tatsuConfig.nonce
            }
        }).then(function (data) {
            var presetsList = Immutable.fromJS(data),
                moduleOptionsData = getState().moduleOptions;
            if ('undefined' != typeof presetsList && 'undefined' != typeof moduleOptionsData) {
                presetsList = presetsList.map(function (presetMap) {

return presetMap.setIn(['content', 0], addDefaultValueToInitialPageContent(presetMap.getIn(['content', 0]), moduleOptionsData));
                    //return presetMap;
                });
            }
            dispatch({
                type: 'LOAD_SECTION_PRESETS',
                presets: presetsList
            });
        }).catch(function (error) {
            dispatch(module.exports.sendMessage('Failed to load section presets', 'error'));
            console.log(error);
        });
    };
};

module.exports.loadFooterPresets = function () {

return function (dispatch, getState) {

return $.ajax({
            type: 'POST',
            url: tatsuConfig.ajaxurl,
            dataType: 'json',
            data: {
                action: 'tatsu_get_footer_concepts',
                nonce: tatsuConfig.nonce
            }
        }).then(function (data) {
            var presetsList = Immutable.fromJS(data),
                moduleOptionsData = getState().moduleOptions;
            if ('undefined' != typeof presetsList && 'undefined' != typeof moduleOptionsData) {
                presetsList = presetsList.map(function (presetMap) {
                    return presetMap.setIn(['content', 0], addDefaultValueToInitialPageContent(presetMap.getIn(['content', 0]), moduleOptionsData));
                });
            }
            dispatch({
                type: 'LOAD_SECTION_PRESETS',
                presets: presetsList
            });
        }).catch(function (error) {
            dispatch(module.exports.sendMessage('Failed to load Footer presets', 'error'));
            console.log(error);
        });
    };
};

module.exports.loadHeaderRowPresets = function () {

return function (dispatch, getState) {

return $.ajax({
            type: 'POST',
            url: tatsuConfig.ajaxurl,
            dataType: 'json',
            data: {
                action: 'tatsu_get_header_concepts',
                nonce: tatsuConfig.nonce
            }
        }).then(function (data) {
            var presetsList = Immutable.fromJS(data),
                moduleOptionsData = getState().moduleOptions;
            if ('undefined' != typeof presetsList && 'undefined' != typeof moduleOptionsData) {
                presetsList = presetsList.map(function (presetMap) {

return presetMap.set('content', presetMap.get('content').map(function (preset) {
                        return addDefaultValueToInitialPageContent(preset, moduleOptionsData);
                    }));
                });
            }
            dispatch({
                type: 'LOAD_HEADER_ROW_PRESETS',
                presets: presetsList
            });
        }).catch(function (error) {
            dispatch(module.exports.sendMessage('Failed to load header row presets', 'error'));
            console.log(error);
        });
    };
};

module.exports.loadTemplateToState = function (templateMap) {
    return { type: 'LOAD_TEMPLATE', template: templateMap };
};

module.exports.appendPrebuiltTemplates = function (collection, collectionType) {
    return {
        type: 'APPEND_TEMPLATE',
        collectionType: collectionType,
        collection: collection
    };
};

//deprecated, not used anymore. Inital State loaded from componentDidMount hook in app.js
module.exports.loadInitialState = function loadInitialState() {

return $.ajax({
                type: 'POST',
                url: tatsuConfig.restapiurl + 'store',
                data: 'post_id=' + tatsuConfig.post_id,
                beforeSend: function beforeSend(xhr) {
                    xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
                }
            }).then(function (data) {

dispatch(module.exports.loadSectionPresets());
                data = JSON.parse(JSON.stringify(data));
                var actualData = Immutable.fromJS(data.tatsu_page_content),
                    moduleOptionsData = Immutable.fromJS(data.tatsu_module_options, function (key, value) {
                    if ('' === key) {
                        return value.toOrderedMap();
                    } else if (Immutable.Iterable.isIndexed(value)) {
                        return value.toList();
                    } else {
                        return value.toMap();
                    }
                });
                if ('undefined' != typeof actualData && 'undefined' != typeof moduleOptionsData) {
                    actualData = addDefaultValueToInitialPageContent(actualData, moduleOptionsData);
                }
                moduleOptionsData = parseModuleOptions(moduleOptionsData);
                dispatch({ type: 'LOAD_MODULE_OPTIONS', moduleOptions: moduleOptionsData }); //Need to change this into a standard action!
                dispatch({ type: 'ADD_INITIAL_DATA', state: actualData });
                if (0 == actualData.get('inner').size) {
                    dispatch(module.exports.addModule(Immutable.List(), 'tatsu_section', 'push'));
                }
                dispatch({ type: 'SET_CURRENT_SAVE_STATE', sectionList: actualData.get('inner') });
                dispatch({ type: 'STATE_LOADED' });
            });
        };
    }
};

module.exports.loadTemplateAsPreset = function loadTemplateAsPreset(name, templateType, collectionType, presetPath) {
    return function (dispatch, getState) {

dispatch(module.exports.sendMessage('', 'loader'));
        return $.ajax({
            type: 'POST',
            url: tatsuConfig.ajaxurl,
            dataType: 'json',
            data: {
                action: 'tatsu_get_template',
                name: name,
                template_type: templateType,
                collection_type: collectionType,
                nonce: tatsuConfig.nonce
            },
            beforeSend: function beforeSend(xhr) {
                xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
            }
        }).then(function (data) {
            var templateList = Immutable.fromJS(data),
                moduleOptions = getState().moduleOptions;
            templateList = templateList.map(function (template) {
                template = changeUuid(template);
                template = addDefaultValueToInitialPageContent(template, moduleOptions);
                return template;
            });
            dispatch({ type: 'ADD_TEMPLATE_AS_PRESET', templateList: templateList, path: presetPath });
            dispatch({ type: 'CLOSE_DRAWER' });
            dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
            dispatch(module.exports.sendMessage('Preset Added!', 'success'));
        }).catch(function (error) {
            console.log(error);
            dispatch({ type: 'CLOSE_DRAWER' });
            dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
            dispatch(module.exports.sendMessage('Unable to Load Preset!', 'error'));
        });
    };
};

module.exports.loadTemplate = function loadTemplate(name, templateType, collectionType) {

return function (dispatch, getState) {
        var lastSectionIndex = getState().tatsu_page_content.getIn(['present', 'inner']).size;
        dispatch(module.exports.sendMessage('', 'loader'));
        return $.ajax({
            type: 'POST',
            url: tatsuConfig.ajaxurl,
            dataType: 'json',
            data: {
                action: 'tatsu_get_template',
                name: name,
                template_type: templateType,
                collection_type: collectionType,
                nonce: tatsuConfig.nonce
            },
            beforeSend: function beforeSend(xhr) {
                xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
            }
        }).then(function (data) {

console.log(error);
            dispatch({ type: 'CLOSE_DRAWER' });
            dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
            dispatch(module.exports.sendMessage('Unable to Load Template!', 'error'));
        });
    };
};
module.exports.saveAsTemplate = function saveAsTemplate(name, title, template, path) {

return function (dispatch, getState) {
        var pageContent = getState().tatsu_page_content.get('present'),
            getInArray = [],
            target = Immutable.Map(),
            targetSection,
            createdDate = (0, _getPrettyDate2.default)(),
            createdBy = tatsuConfig.current_user,
            jsonData;
        if ('sections' === template) {
            getInArray = keyPath(path, '', '');
            targetSection = pageContent.getIn(getInArray);
            target = target.set('inner', Immutable.List().push(targetSection));
        } else {
            target = pageContent;
        }
        jsonData = JSON.stringify(target.toJSON());
        dispatch(module.exports.sendMessage('', 'loader'));

return $.ajax({
            type: 'POST',
            url: tatsuConfig.ajaxurl,
            data: {
                action: 'tatsu_save_template',
                name: name,
                title: title,
                type: template,
                template_content: jsonData,
                created_at: createdDate,
                created_by: createdBy,
                nonce: tatsuConfig.nonce
            },
            beforeSend: function beforeSend(xhr) {
                xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
            }
        }).then(function (data) {
            dispatch({ type: 'CLOSE_DRAWER' });
            if ('false' === data) {
                dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
                dispatch(module.exports.sendMessage('Unable to Save Template!', 'error'));
            } else {
                dispatch({ type: 'SAVE_AS_TEMPLATE', name: name, title: title, templateType: template, createdAt: createdDate, createdBy: createdBy });
                dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
                dispatch(module.exports.sendMessage('Template Saved!', 'success'));
            }
        }).catch(function (error) {
            console.log(error);
            dispatch({ type: 'CLOSE_DRAWER' });
            dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
            dispatch(module.exports.sendMessage('Unable to Save Template!', 'error'));
        });
    };
};

module.exports.deleteTemplate = function deleteTemplate(templateType, name) {

return function (dispatch, getState) {

return $.ajax({
            type: 'POST',
            //url : tatsuConfig.restapiurl+'delete_template',
            url: tatsuConfig.ajaxurl,
            data: {
                action: 'tatsu_delete_template',
                name: name,
                type: templateType,
                nonce: tatsuConfig.nonce
            },
            beforeSend: function beforeSend(xhr) {
                xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
            }
        }).then(function (data) {
            if ('false' === data) {
                dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
                dispatch(module.exports.sendMessage('Unable to Delete Template!', 'error'));
            } else {
                dispatch({ type: 'DELETE_TEMPLATE', name: name, templateType: templateType });
                dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
                dispatch(module.exports.sendMessage('Template Deleted!', 'success'));
            }
        }).catch(function (error) {
            console.log(error);
            dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
            dispatch(module.exports.sendMessage('Unable to Delete Template!', 'error'));
        });
    };
};

module.exports.frameLoaded = function frameLoaded() {
    return {
        type: 'FRAME_LOADED'
    };
};
module.exports.saveData = function saveData() {
    return function (dispatch, getState) {
        var stateData = getState().tatsu_page_content.get('present').get('inner'),
            globalSettings = getState().globalPostDetails,
            moduleOptions = getState().moduleOptions,
            actionHook = getState().builderMode === 'header_builder' ? 'tatsu_save_header_store' : 'tatsu_save_store',
            ajaxdata,
            postName = globalSettings.post_name,
            postStatus = globalSettings.post_status,
            customJs = globalSettings.customJs,
            customCss = globalSettings.customCss,
            jsonData,
            shortcodeStrippedData = stateData.map(function (moduleMap) {
            return stripOutputBeforeSave(moduleMap, moduleOptions);
        });

var headerFonts = stateData.map(function (moduleMap) {
            return getHeaderFonts(moduleMap, moduleOptions);
        });

var fontsToLoad = {};

headerFonts.forEach(function (item) {
            mergeWith(fontsToLoad, item, function (objValue, srcValue) {
                if (getObjectType(objValue) === '[object Array]') {
                    return objValue.concat(srcValue);
                }
            });
        });
        jsonData = JSON.stringify(shortcodeStrippedData.toJSON());
        fontsToLoad = JSON.stringify(fontsToLoad);
        if (getState().builderMode === 'header_builder') {
            var globalSettings = getState().tatsu_page_content.get('present').get('settings');
            globalSettings = JSON.stringify(globalSettings.toJSON());
            ajaxdata = {
                action: 'tatsu_save_header_store',
                post_id: tatsuConfig.post_id,
                page_content: jsonData,
                settings: globalSettings,
                post_name: postName,
                post_status: postStatus,
                tatsu_header_fonts: fontsToLoad,
                nonce: tatsuConfig.nonce
            };
        } else if (getState().builderMode === 'footer_builder') {
            ajaxdata = {
                action: 'tatsu_save_footer_store',
                post_id: tatsuConfig.post_id,
                post_name: postName,
                post_status: postStatus,
                page_content: jsonData,
                nonce: tatsuConfig.nonce
            };
        } else {
            ajaxdata = {
                action: 'tatsu_save_store',
                post_id: tatsuConfig.post_id,
                page_content: jsonData,
                post_name: postName,
                post_status: postStatus,
                tatsu_body_fonts: fontsToLoad,
                nonce: tatsuConfig.nonce
            };
        }
        ajaxdata.custom_js = customJs;
        ajaxdata.custom_css = customCss;
        dispatch(module.exports.sendMessage('', 'loader'));
        return $.ajax({
            type: 'POST',
            url: tatsuConfig.ajaxurl, //tatsuConfig.restapiurl + 'save_store', 
            data: ajaxdata,
            beforeSend: function beforeSend(xhr) {
                xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
            }
        }).then(function (data) {
            // if( 'false' === data ) {
            //    dispatch( { type : 'CLOSE_SNACKBAR', loadState : 1 } );
            //    dispatch( module.exports.sendMessage( 'Unable to Save!', 'error' ) );            
            // }else{
            dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
            dispatch({ type: 'SET_CURRENT_SAVE_STATE', sectionList: stateData });
            dispatch(module.exports.sendMessage('Saved!', 'success'));

if (window.tatsuConfig.revision_data) {
                $.ajax({
                    type: 'POST',
                    url: tatsuConfig.ajaxurl, //tatsuConfig.restapiurl + 'save_store', 
                    data: {
                        action: 'get_revision_data',
                        offset: 0,
                        post_id: window.tatsuConfig.post_id,
                        nonce: tatsuConfig.nonce
                    },
                    beforeSend: function beforeSend(xhr) {
                        xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
                    }
                }).then(function (data) {
                    if (isJSON(data)) {
                        dispatch({ type: 'UPDATE_REVISION_DATA', revisionData: JSON.parse(data), replace: true });
                        dispatch({ type: 'CLEAR_REVISION_BACKUP' });
                        $('body').removeClass('revision-preview');
                        $('body').removeClass('preview');
                    }
                }).catch(function (data) {
                    dispatch({ type: 'CLEAR_REVISION_BACKUP' });
                    $('body').removeClass('revision-preview');
                    $('body').removeClass('preview');
                });
            }

// }
        }).catch(function (error) {
            dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
            dispatch(module.exports.sendMessage('Status Code : ' + error.status + ' - Unable to Save!', 'error'));
        });
    };
};
module.exports.editAtt = function editAtt(path, attName, attValue, moduleOptions, shouldBeRecorded, isResponsive, targetDisplay) {

return {
        type: 'EDIT_MODULE',
        path: path,
        attName: attName,
        attValue: attValue,
        moduleOptions: moduleOptions,
        shouldBeRecorded: shouldBeRecorded,
        isResponsive: isResponsive,
        targetDisplay: targetDisplay
    };
};
module.exports.editModule = function editModule(path, moduleName, attName, attValue, attMap, shouldBeRecorded) {

return function (dispatch, getState) {

dispatch(module.exports.editAtt(path, attMap.getIn(['ajax_options', 'target_att']), result, moduleOptions, shouldBeRecorded, isResponsive, targetDisplay));
                    dispatch({
                        type: 'RESET_SPINNER',
                        path: path
                    });
                }).catch(function (error) {});
            } else {
                dispatch(module.exports.editAtt(path, attName, attValue, moduleOptions, shouldBeRecorded, isResponsive, targetDisplay));
            }
        } else {
            dispatch(module.exports.editAtt(path, attName, attValue, moduleOptions, 0, isResponsive, targetDisplay));
            if (attMap.get('is_ajax')) {
                dispatch({
                    type: 'SET_SPINNER',
                    path: path
                });
                ajaxDataObj.action = attMap.getIn(['ajax_options', 'end_point']);
                ajaxDataObj[attName] = attValue;
                fireAjax(ajaxDataObj).then(function (result) {

dispatch(module.exports.editModule(path, attMap.getIn(['ajax_options', 'target_att']), result, attMap, shouldBeRecorded));
                }).catch(function (error) {});
            } else {
                if ('sub_module' == moduleOptions.getIn([moduleName, 'type'])) {
                    path = path.pop();
                }
                dispatch(module.exports.updateShortcode(path));
            }
        }
    };
};

module.exports.changeTargetDisplay = function changeTargetDisplay(target) {

return function (dispatch, getState) {
        //dispatch( module.exports.resetSelection() );
        dispatch({
            type: 'RESPONSIVE_SWITCH',
            target: target
        });
    };
};

module.exports.sendMessage = function sendMessage(message, type) {

return {

type: 'COMMUNICATE',
        messageType: type,
        message: message

};
};

module.exports.deleteColumnChildren = function deleteColumnChildren(path) {

return {
        type: 'DELETE_COLUMN_CHILDREN',
        path: path
    };
};
module.exports.reorderModules = function (sourcePath, moduleName, dropEffect) {

return function (dispatch, getState) {

var serializedPath,
            selectionController = getState().selectionController,
            pathFromSelectionController,
            targetPath = getState().dragMonitor.get('path'),
            position = getState().dragMonitor.get('position'),
            isInterColumn,
            moduleOptions,
            parentRoute = routeResolve(window.location.pathname);
        dispatch(module.exports.resetSelection());
        browserHistory.push(parentRoute + 'layoutManager/');
        if ('copy' == dropEffect) {
            dispatch(module.exports.resetSelection());
            targetPath = getPathFromPosition(targetPath, position, true);
            dispatch({ type: 'REORDER_NEW', targetPath: targetPath, sourcePath: sourcePath, dropEffect: 'copy' });
            return;
        } else {
            if (0 == targetPath.size || Immutable.is(targetPath, sourcePath) || 'tatsu_inner_row' == moduleName && 4 < targetPath.size) {
                return;
            }
            isInterColumn = !Immutable.is(sourcePath.pop(), targetPath.pop());
            targetPath = getDropTargetPath(sourcePath, getPathFromPosition(targetPath, position, isInterColumn));
            dispatch({ type: 'REORDER_NEW', targetPath: targetPath, sourcePath: sourcePath, dropEffect: 'move' });
            dispatch(module.exports.setSelection(targetPath, 'single'));
        }
    };
};

module.exports.triggerPaste = function triggerPaste(modulePath, shortcodeString) {

return function (dispatch, getState) {

dispatch(module.exports.sendMessage('', 'loader'));

return $.ajax({
            type: 'POST',
            url: tatsuConfig.ajaxurl,
            data: {
                action: 'tatsu_paste_shortcode',
                shortocde: encodeURIComponent(shortcodeString),
                nonce: tatsuConfig.nonce
            },
            beforeSend: function beforeSend(xhr) {
                xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
            }
        }).then(function (data) {

if (Array.isArray(data) && 0 < data.length) {
                var moduleDataList = Immutable.fromJS(data),
                    stateBeforePaste = getState().tatsu_page_content.get('present'),
                    stateAfterPaste,
                    moduleOptions = getState().moduleOptions;
                moduleDataList = moduleDataList.map(function (moduleData) {

return addDefaultValueToInitialPageContent(moduleData, moduleOptions);
                });

dispatch(module.exports.addPastedModules(moduleDataList, modulePath, getState().builderMode));
                stateAfterPaste = getState().tatsu_page_content.get('present');
                dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });

if (!Immutable.is(stateBeforePaste, stateAfterPaste)) {
                    dispatch(module.exports.sendMessage('All modules pasted successfully', 'success'));
                } else {
                    dispatch(module.exports.sendMessage('Failed to paste all the modules', 'error'));
                }
            } else {
                //error
                dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
                dispatch(module.exports.sendMessage(' Unrecognized shortcode!', 'error'));
            }
        }).catch(function (error) {
            console.log(error);
            dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
            dispatch(module.exports.sendMessage('Network error, Operation cannot be completed!', 'error'));
        });
    };
};

module.exports.addPastedModules = function addPastedModules(moduleDataList, modulePath, builderMode) {

return {
        type: 'ADD_PASTED_MODULES',
        moduleList: moduleDataList,
        modulePath: modulePath,
        builderMode: builderMode
    };
};

module.exports.undo = function undo() {

return function (dispatch, getState) {

var parentRoute = routeResolve(window.location.pathname);
        browserHistory.push(parentRoute + 'layoutManager/');
        dispatch(module.exports.resetSelection());
        dispatch(module.exports.closeDrawer());
        dispatch(module.exports.closeContextMenu());
        dispatch({ type: 'UNDO_ACTION' });
    };
};

module.exports.redo = function redo() {

return function (dispatch, getState) {

return {
        type: 'REPOSITION_INLINE_TOOLBAR',
        activeEditorId: activeEditorId,
        currentTop: currentTop,
        currentLeft: currentLeft
    };
};
module.exports.resetRetriggerInlineToolbar = function () {

return {
        type: 'RESET_INLINE_RETRIGGER'
    };
};

module.exports.setActiveEditorId = function (activeEditorId) {

return function (dispatch, getState) {

return function (dispatch, getState) {
        if (null == path) {
            path = getPathFromUrl();
        }
        if (null == editorId) {
            editorId = getState().inlineController.get('activeEditorId');
        }
        var moduleOptions = getState().moduleOptions,
            contentData,
            activeEditor = document.getElementById('tatsu-preview').contentWindow.tinymce.get(editorId);
        if (null != activeEditor) {
            contentData = activeEditor.getContent();
            if ('string' == typeof editorId && '' != editorId) {
                dispatch(module.exports.editAtt(path, 'content', contentData, moduleOptions, 1, false, ''));
            }
        } else {
            dispatch({
                type: 'RESET_INLINE_TOOLBAR'
            });
        }
    };
};
module.exports.resetInlineToolbar = function () {

return function (dispatch, getState) {

return {
        type: 'TOGGLE_INLINE_TOOL',
        tool: tool
    };
};
module.exports.toggleInlineOverride = function (override) {

return {
        type: 'TOGGLE_INLINE_OVERRIDE',
        override: override
    };
};
module.exports.openDrawer = function (drawerType, metaMap) {

return function (dispatch, getState) {
        var currentDrawerState = getState().drawerController,
            currentDrawerType = currentDrawerState.get('type');
        if (currentDrawerState.get('open')) {
            if (currentDrawerType != drawerType) {
                dispatch(module.exports.closeDrawer());
                setTimeout(dispatch.bind(null, module.exports.openDrawer(drawerType, metaMap)), 400);
            } else {
                dispatch({
                    type: 'OPEN_DRAWER',
                    currentDrawerType: drawerType,
                    drawerMeta: metaMap
                });
            }
        } else {
            dispatch({
                type: 'OPEN_DRAWER',
                currentDrawerType: drawerType,
                drawerMeta: metaMap
            });
        }
    };
};
module.exports.closeDrawer = function () {

return function (dispatch, getState) {

return function (dispatch, getState) {

var currentSelectionState = getState().selectionController,
            pathFromSelectionController = Immutable.List(),
            selectionType = currentSelectionState.get('type');
        document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
        if ('multi' == selectionType) {
            pathFromSelectionController = currentSelectionState.get('selectionList').map(function (curSelection) {

return curSelection.get('path');
            });
        } else if ('single' == selectionType) {
            pathFromSelectionController = currentSelectionState.getIn(['selectionList', 0, 'path']);
        }
        if ('' == selectionType || 'multi' == selectionType && !pathFromSelectionController.contains(modulePath) || 'single' == selectionType && !Immutable.is(pathFromSelectionController, modulePath)) {
            selectionType = 'single';
            dispatch(module.exports.setSelection(modulePath, 'single'));
        }
        dispatch(module.exports.closeDrawer());
        dispatch({
            type: 'OPEN_CONTEXT_MENU',
            top: top,
            left: left,
            path: 'multi' == selectionType ? pathFromSelectionController : modulePath,
            name: 'multi' == selectionType ? 'Multiple Selection' : moduleName,
            title: moduleTitle,
            id: moduleId,
            clientRect: clientRect,
            builderType: builderType || 'core'
        });
    };
};
module.exports.closeContextMenu = function () {

return {
        type: 'CLOSE_CONTEXT_MENU'
    };
};
module.exports.copyAttributes = function () {

return function (dispatch, getState) {

return function (dispatch, getState) {

return function (dispatch, getState) {

var dummyElement = document.createElement('textarea'),
            pathArray,
            requiredModule,
            moduleTitle,
            countOfColsInMultiSelect = 0,
            moduleOptions = getState().moduleOptions,
            selection = document.getElementById('tatsu-preview').contentWindow.getSelection(),
            shortcodeData = '',
            verbToBeUsedInSuccessMessage = 'cut' == action ? ' moved' : ' copied',
            verbToBeUsedInFailureMessage = 'cut' == action ? ' move' : ' copy',
            iframeBody = document.getElementById('tatsu-preview').contentDocument.getElementsByTagName('body')[0],
            result = false;
        if (null != iframeBody) {
            dummyElement.style.opacity = '0';
            dummyElement.style.position = 'fixed';
            dummyElement.style.pointerEvents = 'none';
            dummyElement.style.top = 0;
            dummyElement.style.left = 0;
            dummyElement.style.width = '2em';
            dummyElement.style.height = '2em';
            dummyElement.style.padding = 0;
            dummyElement.style.border = 'none';
            dummyElement.style.outline = 'none';
            dummyElement.style.boxShadow = 'none';
            dummyElement.style.background = 'transparent';
            dummyElement.style.zIndex = -1;
            if (Immutable.List.isList(path.get(0))) {
                moduleTitle = 'Multiple Modules';
                path.forEach(function (curPath) {

pathArray = keyPath(curPath, 'present', '');
                    requiredModule = getState().tatsu_page_content.getIn(pathArray);
                    if ('tatsu_column' == requiredModule.get('name') || 'tatsu_inner_column' == requiredModule.get('name')) {
                        countOfColsInMultiSelect++;
                        return;
                    }
                    shortcodeData = shortcodeData + getShortcode(stripOutputBeforeSave(requiredModule, moduleOptions));
                });
                if (countOfColsInMultiSelect == path.size) {
                    dispatch(module.exports.sendMessage('Columns/Inner Columns cannot be copied/cut', 'error'));
                    return;
                }
            } else {
                pathArray = keyPath(path, 'present', '');
                requiredModule = getState().tatsu_page_content.getIn(pathArray);
                if ('tatsu_column' == requiredModule.get('name') || 'tatsu_inner_column' == requiredModule.get('name')) {
                    dispatch(module.exports.sendMessage('Columns/Inner Columns cannot be copied/cut', 'error'));
                    return;
                }
                moduleTitle = moduleOptions.getIn([requiredModule.get('name'), 'title']);
                shortcodeData = getShortcode(stripOutputBeforeSave(requiredModule, moduleOptions));
            }
            dummyElement.value = shortcodeData;
            iframeBody.appendChild(dummyElement);
            dummyElement.select();
            try {
                result = document.getElementById('tatsu-preview').contentDocument.execCommand('copy');
            } catch (error) {
                console.log(error);
            }
            iframeBody.removeChild(dummyElement);
        }
        if (result) {
            if ('cut' == action) {
                dispatch(module.exports.deleteModule(path, requiredModule.get('name')));
            }
            dispatch(module.exports.sendMessage(moduleTitle + verbToBeUsedInSuccessMessage + ' to Clipboard', 'success'));
        } else {
            dispatch(module.exports.sendMessage('Unable to ' + verbToBeUsedInFailureMessage + ' module to clipboard!', 'error'));
        }
    };
};
module.exports.startDrag = function (dragType) {
    return function (dispatch, getState) {

return function (dispatch, getState) {

return function (dispatch, getState) {

if (!getState().dragMonitor.get('isDragging')) {
            dispatch({
                type: 'SET_DROP_EFFECT',
                dropEffect: dropEffect
            });
        }
    };
};
module.exports.setDragPlaceholder = function (path, position) {

return function (dispatch, getState) {

return function (dispatch, getState) {

return function (dispatch, getState) {

var currentSelectionState = getState().selectionController,
            moduleOptions,
            pathArray,
            currentPathList,
            moduleData,
            moduleName,
            isUniqueSelection = false,
            isSubModule = false,
            moduleType,
            moduleTitle,
            parentRoute,
            encodedPath,
            moduleId,
            dragHandle,
            targetNode,
            clientRectLeft,
            offsetTop,
            builderMode = getState().builderMode,
            parentComponent = parentComponentFinder(path).get('name');

if (currentSelectionState.get('type') != selectionType) {
            isUniqueSelection = true;
        } else {
            if ('single' == selectionType) {
                moduleOptions = getState().moduleOptions;
                pathArray = null == pathArray ? keyPath(path, 'present', '') : pathArray;
                moduleData = null == moduleData ? getState().tatsu_page_content.getIn(pathArray) : moduleData;
                moduleName = moduleData.get('name');
                moduleType = moduleOptions.getIn([moduleName, 'type']);
                moduleId = moduleData.get('id');
                isUniqueSelection = currentSelectionState.getIn(['selectionList', 0, 'id']) != moduleId || moduleType === 'multi' ? true : false;
            } else {
                isUniqueSelection = true;
            }
        }
        if (isUniqueSelection) {
            moduleOptions = getState().moduleOptions;
            pathArray = null == pathArray ? keyPath(path, 'present', '') : pathArray;
            moduleData = null == moduleData ? getState().tatsu_page_content.getIn(pathArray) : moduleData;
            moduleName = moduleData.get('name');
            moduleType = moduleOptions.getIn([moduleName, 'type']);
            moduleId = moduleData.get('id');
            // if( 'sub_module' == moduleType || ( ( 'tatsu_button' == moduleName || 'tatsu_icon' == moduleName ) && ( 'page_builder' === builderMode && 1 == path.size%2 ) ) ) {
            if ('sub_module' == moduleType || 'tatsu_button_group' == parentComponent || 'tatsu_icon_group' == parentComponent) {
                isSubModule = true;
                pathArray = keyPath(path.pop(), 'present', '');
                moduleData = getState().tatsu_page_content.getIn(pathArray);
                moduleName = moduleData.get('name');
                moduleId = moduleData.get('id');
                moduleType = moduleData.get('type');
            }
            parentRoute = routeResolve(window.location.pathname);
            encodedPath = encodePath(path.toArray().toString());
            dragHandle = moduleOptions.getIn([moduleName, 'drag_handle']);
            targetNode = document.getElementById('tatsu-preview').contentDocument.getElementsByClassName('be-pb-observer-' + moduleId)[0];
            if (null != targetNode) {
                clientRectLeft = targetNode.getBoundingClientRect().left;
                offsetTop = getScrollDistance(targetNode);
            } else {
                clientRectLeft = 0;
                offsetTop = 0;
            }
            moduleTitle = 1 == path.size ? moduleData.getIn(['atts', 'section_title']) || moduleOptions.getIn([moduleName, 'title']) : moduleOptions.getIn([moduleName, 'title']);

var frameWidth = window.innerWidth - 300,
                //300px left panel
            observerWidth = 300;

if (frameWidth - clientRectLeft < observerWidth) {
                var observerVisible = frameWidth - clientRectLeft,
                    observerOverflow = observerWidth - observerVisible;

clientRectLeft = clientRectLeft - observerOverflow;
            }

if (true != forceShowLayoutManager || 'tatsu_inner_row' != moduleName || 'tatsu_row' != moduleName) {
                dispatch({
                    type: 'SET_SELECTION',
                    path: isSubModule ? path.pop() : path,
                    top: offsetTop,
                    left: clientRectLeft,
                    name: moduleName,
                    title: moduleTitle,
                    hide: false,
                    id: moduleId,
                    dragHandle: dragHandle,
                    selectionType: selectionType,
                    builderType: moduleType
                });
            } else {
                dispatch(module.exports.resetSelection());
            }
            if ('single' == selectionType) {
                // if( ( true === forceShowLayoutManager && ( 'tatsu_inner_row' == moduleName || 'tatsu_row' == moduleName ) ) ) {
                //     browserHistory.push( parentRoute + 'layoutManager/' + encodedPath );
                // }else {
                browserHistory.push(parentRoute + 'moduleEditor/' + encodedPath + '/' + moduleId);
                //  }
            } else {
                browserHistory.push(parentRoute + 'moduleEditor/multiSelect//');
            }
        } else {
            var parentRoute = routeResolve(window.location.pathname);
            if (window.location.pathname === parentRoute + 'layoutManager/') {

pathArray = null == pathArray ? keyPath(path, 'present', '') : pathArray;
                moduleData = null == moduleData ? getState().tatsu_page_content.getIn(pathArray) : moduleData;
                moduleId = moduleData.get('id');

var encodedPath = encodePath(path.toArray().toString());

browserHistory.push(parentRoute + 'moduleEditor/' + encodedPath + '/' + moduleId);
            }
        }
    };
};

module.exports.hideSelection = function () {
    return {
        type: 'HIDE_SELECTION'
    };
};
module.exports.showSelection = function () {
    return {
        type: 'SHOW_SELECTION'
    };
};

module.exports.changeSelectionPosition = function (targetNode, currentTop, currentLeft) {

return function (dispatch, getState) {

dispatch({
            type: 'CHANGE_SELECTION_POSITION',
            top: currentTop,
            left: currentLeft
        });
    };
};

module.exports.reinitSelection = function () {

return function (dispatch, getState) {

var currentSelectionPath = getState().selectionController.get('path');
        dispatch(module.exports.setSelection(currentSelectionPath, 'single'));
    };
};
module.exports.resetSelection = function () {

return {
        type: 'RESET_SELECTION'
    };
};
module.exports.openSectionRenameHandler = function (sectionPath, sectionTitle, currentTop, currentLeft) {

return function (dispatch, getState) {

var moduleOptionsData = getState().moduleOptions,
            currentTitle = sectionTitle || moduleOptionsData.getIn(['tatsu_section', 'title']);
        dispatch({
            type: 'SHOW_RENAME_TOOL',
            top: currentTop,
            left: currentLeft,
            title: currentTitle,
            path: sectionPath
        });
    };
};
module.exports.changeTitle = function (modulePath, desiredTitle) {

return {
        type: 'CHANGE_TITLE',
        title: desiredTitle,
        path: modulePath
    };
};
module.exports.hideSectionRenameHandler = function () {

return function (dispatch, getState) {

var currentSectionHandlerState = getState().sectionRenameController;
        if (currentSectionHandlerState.get('open')) {
            dispatch({
                type: 'HIDE_RENAME_TOOL'
            });
        }
    };
};

module.exports.loadSelectedRevision = function (revision_id) {
    return function (dispatch, getState) {
        if (revision_id === 'current') {
            $('body').removeClass('revision-preview');
            $('body').removeClass('preview');
            if (getState().revisionHelper.backedUp) {
                dispatch({ type: 'LOAD_POST_REVISION', data: getState().revisionHelper.state });
                dispatch({ type: 'CLEAR_REVISION_BACKUP' });
            }
        } else if (revision_id) {
            dispatch(module.exports.sendMessage('', 'loader'));
            dispatch({ type: 'UPDATE_SELECTED_REVISION', selectedRevision: revision_id });
            dispatch({ type: 'SET_LOADING_STATE', isLoading: true });

$.ajax({
                type: 'POST',
                url: window.tatsuConfig.ajaxurl,
                data: {
                    action: 'get_revision_content',
                    revision_id: revision_id,
                    post_id: window.tatsuConfig.post_id,
                    nonce: window.tatsuConfig.nonce
                },
                beforeSend: function beforeSend(xhr) {
                    xhr.setRequestHeader('X-WP-Nonce', window.tatsuConfig.nonce);
                }
            }).then(function (data) {
                dispatch({ type: 'SET_LOADING_STATE', isLoading: false });
                var actualData = Immutable.fromJS(JSON.parse(data)),
                    moduleOptionsData = getState().moduleOptions;
                if ('undefined' != typeof actualData && 'undefined' != typeof moduleOptionsData) {
                    actualData = actualData.map(function (curData) {
                        return addDefaultValueToInitialPageContent(curData, moduleOptionsData);
                    });
                }

if (!getState().revisionHelper.backedUp) {
                    dispatch({ type: 'BACKUP_CURRENT_STATE', data: getState().tatsu_page_content.getIn(['present', 'inner']) });
                }

dispatch({ type: 'LOAD_POST_REVISION', data: actualData });
                $('body').addClass('revision-preview');
                $('body').addClass('preview');

store.dispatch(module.exports.resetSelection());
                store.dispatch(module.exports.closeContextMenu());

dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
                dispatch(module.exports.sendMessage('Loaded Successfully', 'success'));
            }).catch(function (error) {
                dispatch({ type: 'UPDATE_SELECTED_REVISION', selectedRevision: 'current' });
                dispatch({ type: 'SET_LOADING_STATE', isLoading: false });
                dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
                dispatch(module.exports.sendMessage('Status Code : ' + error.status + ' - Unable to Load Revision!', 'error'));
            });
        } else {
            dispatch({ type: 'UPDATE_SELECTED_REVISION', selectedRevision: '' });
        }
    };
};

module.exports.loadMoreRevisionData = function () {
    return function (dispatch, getState) {
        var revisionCount = getState().revisionHelper.revisionData.revisions.length;
        dispatch({ type: 'REVISION_DATA_LOADING', isLoading: true });
        $.ajax({
            type: 'POST',
            url: window.tatsuConfig.ajaxurl,
            data: {
                action: 'get_revision_data',
                offset: revisionCount,
                post_id: window.tatsuConfig.post_id,
                nonce: tatsuConfig.nonce
            },
            beforeSend: function beforeSend(xhr) {
                xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
            }
        }).then(function (data) {
            dispatch({ type: 'REVISION_DATA_LOADING', isLoading: false });
            if (isJSON(data)) {
                dispatch({ type: 'UPDATE_REVISION_DATA', revisionData: JSON.parse(data) });
            }
        });
    };
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {module.exports = global["Immutable"] = __webpack_require__(955);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*eslint-disable no-unused-vars*/
/*!
 * jQuery JavaScript Library v3.1.0
 * https://jquery.com/
 *
 * Includes Sizzle.js
 * https://sizzlejs.com/
 *
 * Copyright jQuery Foundation and other contributors
 * Released under the MIT license
 * https://jquery.org/license
 *
 * Date: 2016-07-07T21:44Z
 */
( function( global, factory ) {

"use strict";

if ( typeof module === "object" && typeof module.exports === "object" ) {

// For CommonJS and CommonJS-like environments where a proper `window`
		// is present, execute the factory and get jQuery.
		// For environments that do not have a `window` with a `document`
		// (such as Node.js), expose a factory as module.exports.
		// This accentuates the need for the creation of a real `window`.
		// e.g. var jQuery = require("jquery")(window);
		// See ticket #14549 for more info.
		module.exports = global.document ?
			factory( global, true ) :
			function( w ) {
				if ( !w.document ) {
					throw new Error( "jQuery requires a window with a document" );
				}
				return factory( w );
			};
	} else {
		factory( global );
	}

// Pass this if window is not defined yet
} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {

// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
// enough that all such attempts are guarded in a try block.
"use strict";

var arr = [];

var document = window.document;

var getProto = Object.getPrototypeOf;

var slice = arr.slice;

var concat = arr.concat;

var push = arr.push;

var indexOf = arr.indexOf;

var class2type = {};

var toString = class2type.toString;

var hasOwn = class2type.hasOwnProperty;

var fnToString = hasOwn.toString;

var ObjectFunctionString = fnToString.call( Object );

var support = {};

function DOMEval( code, doc ) {
		doc = doc || document;

var script = doc.createElement( "script" );

script.text = code;
		doc.head.appendChild( script ).parentNode.removeChild( script );
	}
/* global Symbol */
// Defining this global in .eslintrc would create a danger of using the global
// unguarded in another place, it seems safer to define global only for this module

var
	version = "3.1.0",

// Define a local copy of jQuery
	jQuery = function( selector, context ) {

// The jQuery object is actually just the init constructor 'enhanced'
		// Need init if jQuery is called (just allow error to be thrown if not included)
		return new jQuery.fn.init( selector, context );
	},

// Support: Android <=4.0 only
	// Make sure we trim BOM and NBSP
	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,

// Matches dashed string for camelizing
	rmsPrefix = /^-ms-/,
	rdashAlpha = /-([a-z])/g,

// Used by jQuery.camelCase as callback to replace()
	fcamelCase = function( all, letter ) {
		return letter.toUpperCase();
	};

jQuery.fn = jQuery.prototype = {

// The current version of jQuery being used
	jquery: version,

constructor: jQuery,

// The default length of a jQuery object is 0
	length: 0,

toArray: function() {
		return slice.call( this );
	},

// Get the Nth element in the matched element set OR
	// Get the whole matched element set as a clean array
	get: function( num ) {
		return num != null ?

// Return just the one element from the set
			( num < 0 ? this[ num + this.length ] : this[ num ] ) :

// Return all the elements in a clean array
			slice.call( this );
	},

// Take an array of elements and push it onto the stack
	// (returning the new matched element set)
	pushStack: function( elems ) {

// Build a new jQuery matched element set
		var ret = jQuery.merge( this.constructor(), elems );

// Add the old object onto the stack (as a reference)
		ret.prevObject = this;

// Return the newly-formed element set
		return ret;
	},

// Execute a callback for every element in the matched set.
	each: function( callback ) {
		return jQuery.each( this, callback );
	},

map: function( callback ) {
		return this.pushStack( jQuery.map( this, function( elem, i ) {
			return callback.call( elem, i, elem );
		} ) );
	},

slice: function() {
		return this.pushStack( slice.apply( this, arguments ) );
	},

first: function() {
		return this.eq( 0 );
	},

last: function() {
		return this.eq( -1 );
	},

eq: function( i ) {
		var len = this.length,
			j = +i + ( i < 0 ? len : 0 );
		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
	},

end: function() {
		return this.prevObject || this.constructor();
	},

// For internal use only.
	// Behaves like an Array's method, not like a jQuery method.
	push: push,
	sort: arr.sort,
	splice: arr.splice
};

jQuery.extend = jQuery.fn.extend = function() {
	var options, name, src, copy, copyIsArray, clone,
		target = arguments[ 0 ] || {},
		i = 1,
		length = arguments.length,
		deep = false;

// Handle a deep copy situation
	if ( typeof target === "boolean" ) {
		deep = target;

// Skip the boolean and the target
		target = arguments[ i ] || {};
		i++;
	}

// Handle case when target is a string or something (possible in deep copy)
	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
		target = {};
	}

// Extend jQuery itself if only one argument is passed
	if ( i === length ) {
		target = this;
		i--;
	}

for ( ; i < length; i++ ) {

// Only deal with non-null/undefined values
		if ( ( options = arguments[ i ] ) != null ) {

// Extend the base object
			for ( name in options ) {
				src = target[ name ];
				copy = options[ name ];

// Prevent never-ending loop
				if ( target === copy ) {
					continue;
				}

// Recurse if we're merging plain objects or arrays
				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
					( copyIsArray = jQuery.isArray( copy ) ) ) ) {

if ( copyIsArray ) {
						copyIsArray = false;
						clone = src && jQuery.isArray( src ) ? src : [];

} else {
						clone = src && jQuery.isPlainObject( src ) ? src : {};
					}

// Never move original objects, clone them
					target[ name ] = jQuery.extend( deep, clone, copy );

// Don't bring in undefined values
				} else if ( copy !== undefined ) {
					target[ name ] = copy;
				}
			}
		}
	}

// Return the modified object
	return target;
};

jQuery.extend( {

// Unique for each copy of jQuery on the page
	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),

// Assume jQuery is ready without the ready module
	isReady: true,

error: function( msg ) {
		throw new Error( msg );
	},

noop: function() {},

isFunction: function( obj ) {
		return jQuery.type( obj ) === "function";
	},

isArray: Array.isArray,

isWindow: function( obj ) {
		return obj != null && obj === obj.window;
	},

isNumeric: function( obj ) {

// As of jQuery 3.0, isNumeric is limited to
		// strings and numbers (primitives or objects)
		// that can be coerced to finite numbers (gh-2662)
		var type = jQuery.type( obj );
		return ( type === "number" || type === "string" ) &&

// parseFloat NaNs numeric-cast false positives ("")
			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
			// subtraction forces infinities to NaN
			!isNaN( obj - parseFloat( obj ) );
	},

isPlainObject: function( obj ) {
		var proto, Ctor;

// Detect obvious negatives
		// Use toString instead of jQuery.type to catch host objects
		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
			return false;
		}

proto = getProto( obj );

// Objects with no prototype (e.g., `Object.create( null )`) are plain
		if ( !proto ) {
			return true;
		}

// Objects with prototype are plain iff they were constructed by a global Object function
		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
	},

isEmptyObject: function( obj ) {

/* eslint-disable no-unused-vars */
		// See https://github.com/eslint/eslint/issues/6125
		var name;

for ( name in obj ) {
			return false;
		}
		return true;
	},

type: function( obj ) {
		if ( obj == null ) {
			return obj + "";
		}

// Support: Android <=2.3 only (functionish RegExp)
		return typeof obj === "object" || typeof obj === "function" ?
			class2type[ toString.call( obj ) ] || "object" :
			typeof obj;
	},

// Evaluates a script in a global context
	globalEval: function( code ) {
		DOMEval( code );
	},

// Convert dashed to camelCase; used by the css and data modules
	// Support: IE <=9 - 11, Edge 12 - 13
	// Microsoft forgot to hump their vendor prefix (#9572)
	camelCase: function( string ) {
		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
	},

nodeName: function( elem, name ) {
		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
	},

each: function( obj, callback ) {
		var length, i = 0;

if ( isArrayLike( obj ) ) {
			length = obj.length;
			for ( ; i < length; i++ ) {
				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
					break;
				}
			}
		} else {
			for ( i in obj ) {
				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
					break;
				}
			}
		}

return obj;
	},

// Support: Android <=4.0 only
	trim: function( text ) {
		return text == null ?
			"" :
			( text + "" ).replace( rtrim, "" );
	},

// results is for internal usage only
	makeArray: function( arr, results ) {
		var ret = results || [];

if ( arr != null ) {
			if ( isArrayLike( Object( arr ) ) ) {
				jQuery.merge( ret,
					typeof arr === "string" ?
					[ arr ] : arr
				);
			} else {
				push.call( ret, arr );
			}
		}

return ret;
	},

inArray: function( elem, arr, i ) {
		return arr == null ? -1 : indexOf.call( arr, elem, i );
	},

// Support: Android <=4.0 only, PhantomJS 1 only
	// push.apply(_, arraylike) throws on ancient WebKit
	merge: function( first, second ) {
		var len = +second.length,
			j = 0,
			i = first.length;

for ( ; j < len; j++ ) {
			first[ i++ ] = second[ j ];
		}

first.length = i;

return first;
	},

grep: function( elems, callback, invert ) {
		var callbackInverse,
			matches = [],
			i = 0,
			length = elems.length,
			callbackExpect = !invert;

// Go through the array, only saving the items
		// that pass the validator function
		for ( ; i < length; i++ ) {
			callbackInverse = !callback( elems[ i ], i );
			if ( callbackInverse !== callbackExpect ) {
				matches.push( elems[ i ] );
			}
		}

return matches;
	},

// arg is for internal usage only
	map: function( elems, callback, arg ) {
		var length, value,
			i = 0,
			ret = [];

// Go through the array, translating each of the items to their new values
		if ( isArrayLike( elems ) ) {
			length = elems.length;
			for ( ; i < length; i++ ) {
				value = callback( elems[ i ], i, arg );

if ( value != null ) {
					ret.push( value );
				}
			}

// Go through every key on the object,
		} else {
			for ( i in elems ) {
				value = callback( elems[ i ], i, arg );

if ( value != null ) {
					ret.push( value );
				}
			}
		}

// Flatten any nested arrays
		return concat.apply( [], ret );
	},

// A global GUID counter for objects
	guid: 1,

// Bind a function to a context, optionally partially applying any
	// arguments.
	proxy: function( fn, context ) {
		var tmp, args, proxy;

if ( typeof context === "string" ) {
			tmp = fn[ context ];
			context = fn;
			fn = tmp;
		}

// Quick check to determine if target is callable, in the spec
		// this throws a TypeError, but we will just return undefined.
		if ( !jQuery.isFunction( fn ) ) {
			return undefined;
		}

// Simulated bind
		args = slice.call( arguments, 2 );
		proxy = function() {
			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
		};

// Set the guid of unique handler to the same of original handler, so it can be removed
		proxy.guid = fn.guid = fn.guid || jQuery.guid++;

return proxy;
	},

now: Date.now,

// jQuery.support is not used in Core but other projects attach their
	// properties to it so it needs to exist.
	support: support
} );

if ( typeof Symbol === "function" ) {
	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
}

// Populate the class2type map
jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
function( i, name ) {
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
} );

function isArrayLike( obj ) {

// Support: real iOS 8.2 only (not reproducible in simulator)
	// `in` check used to prevent JIT error (gh-2145)
	// hasOwn isn't used here due to false negatives
	// regarding Nodelist length in IE
	var length = !!obj && "length" in obj && obj.length,
		type = jQuery.type( obj );

if ( type === "function" || jQuery.isWindow( obj ) ) {
		return false;
	}

return type === "array" || length === 0 ||
		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
}
var Sizzle =
/*!
 * Sizzle CSS Selector Engine v2.3.0
 * https://sizzlejs.com/
 *
 * Copyright jQuery Foundation and other contributors
 * Released under the MIT license
 * http://jquery.org/license
 *
 * Date: 2016-01-04
 */
(function( window ) {

var i,
	support,
	Expr,
	getText,
	isXML,
	tokenize,
	compile,
	select,
	outermostContext,
	sortInput,
	hasDuplicate,

// Local document vars
	setDocument,
	document,
	docElem,
	documentIsHTML,
	rbuggyQSA,
	rbuggyMatches,
	matches,
	contains,

// Instance-specific data
	expando = "sizzle" + 1 * new Date(),
	preferredDoc = window.document,
	dirruns = 0,
	done = 0,
	classCache = createCache(),
	tokenCache = createCache(),
	compilerCache = createCache(),
	sortOrder = function( a, b ) {
		if ( a === b ) {
			hasDuplicate = true;
		}
		return 0;
	},

// Instance methods
	hasOwn = ({}).hasOwnProperty,
	arr = [],
	pop = arr.pop,
	push_native = arr.push,
	push = arr.push,
	slice = arr.slice,
	// Use a stripped-down indexOf as it's faster than native
	// https://jsperf.com/thor-indexof-vs-for/5
	indexOf = function( list, elem ) {
		var i = 0,
			len = list.length;
		for ( ; i < len; i++ ) {
			if ( list[i] === elem ) {
				return i;
			}
		}
		return -1;
	},

// Regular expressions

// http://www.w3.org/TR/css3-selectors/#whitespace
	whitespace = "[\\x20\\t\\r\\n\\f]",

// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",

// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
		// Operator (capture 2)
		"*([*^$|!~]?=)" + whitespace +
		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
		"*\\]",

pseudos = ":(" + identifier + ")(?:\$(" +
		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
		// 1. quoted (capture 3; capture 4 or capture 5)
		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
		// 2. simple (capture 6)
		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
		// 3. anything else (capture 2)
		".*" +
		")\$|)",

// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
	rwhitespace = new RegExp( whitespace + "+", "g" ),
	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),

rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),

rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),

rpseudo = new RegExp( pseudos ),
	ridentifier = new RegExp( "^" + identifier + "$" ),

matchExpr = {
		"ID": new RegExp( "^#(" + identifier + ")" ),
		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
		"ATTR": new RegExp( "^" + attributes ),
		"PSEUDO": new RegExp( "^" + pseudos ),
		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\$" + whitespace +
			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
			"*(\\d+)|))" + whitespace + "*\$|)", "i" ),
		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
		// For use in libraries implementing .is()
		// We use this for POS matching in `select`
		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\$" +
			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\$|)(?=[^-]|$)", "i" )
	},

rinputs = /^(?:input|select|textarea|button)$/i,
	rheader = /^h\d$/i,

rnative = /^[^{]+\{\s*\[native \w/,

// Easily-parseable/retrievable ID or TAG or CLASS selectors
	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,

rsibling = /[+~]/,

// CSS escapes
	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
	funescape = function( _, escaped, escapedWhitespace ) {
		var high = "0x" + escaped - 0x10000;
		// NaN means non-codepoint
		// Support: Firefox<24
		// Workaround erroneous numeric interpretation of +"0x"
		return high !== high || escapedWhitespace ?
			escaped :
			high < 0 ?
				// BMP codepoint
				String.fromCharCode( high + 0x10000 ) :
				// Supplemental Plane codepoint (surrogate pair)
				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
	},

// CSS string/identifier serialization
	// https://drafts.csswg.org/cssom/#common-serializing-idioms
	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g,
	fcssescape = function( ch, asCodePoint ) {
		if ( asCodePoint ) {

// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
			if ( ch === "\0" ) {
				return "\uFFFD";
			}

// Control characters and (dependent upon position) numbers get escaped as code points
			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
		}

// Other potentially-special ASCII characters get backslash-escaped
		return "\\" + ch;
	},

// Used for iframes
	// See setDocument()
	// Removing the function wrapper causes a "Permission Denied"
	// error in IE
	unloadHandler = function() {
		setDocument();
	},

disabledAncestor = addCombinator(
		function( elem ) {
			return elem.disabled === true;
		},
		{ dir: "parentNode", next: "legend" }
	);

// Optimize for push.apply( _, NodeList )
try {
	push.apply(
		(arr = slice.call( preferredDoc.childNodes )),
		preferredDoc.childNodes
	);
	// Support: Android<4.0
	// Detect silently failing push.apply
	arr[ preferredDoc.childNodes.length ].nodeType;
} catch ( e ) {
	push = { apply: arr.length ?

// Leverage slice if possible
		function( target, els ) {
			push_native.apply( target, slice.call(els) );
		} :

// Support: IE<9
		// Otherwise append directly
		function( target, els ) {
			var j = target.length,
				i = 0;
			// Can't trust NodeList.length
			while ( (target[j++] = els[i++]) ) {}
			target.length = j - 1;
		}
	};
}

function Sizzle( selector, context, results, seed ) {
	var m, i, elem, nid, match, groups, newSelector,
		newContext = context && context.ownerDocument,

// nodeType defaults to 9, since context defaults to document
		nodeType = context ? context.nodeType : 9;

results = results || [];

// Return early from calls with invalid selector or context
	if ( typeof selector !== "string" || !selector ||
		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {

return results;
	}

// Try to shortcut find operations (as opposed to filters) in HTML documents
	if ( !seed ) {

if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
			setDocument( context );
		}
		context = context || document;

if ( documentIsHTML ) {

// If the selector is sufficiently simple, try using a "get*By*" DOM method
			// (excepting DocumentFragment context, where the methods don't exist)
			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {

// ID selector
				if ( (m = match[1]) ) {

// Document context
					if ( nodeType === 9 ) {
						if ( (elem = context.getElementById( m )) ) {

// Support: IE, Opera, Webkit
							// TODO: identify versions
							// getElementById can match elements by name instead of ID
							if ( elem.id === m ) {
								results.push( elem );
								return results;
							}
						} else {
							return results;
						}

// Element context
					} else {

// Support: IE, Opera, Webkit
						// TODO: identify versions
						// getElementById can match elements by name instead of ID
						if ( newContext && (elem = newContext.getElementById( m )) &&
							contains( context, elem ) &&
							elem.id === m ) {

results.push( elem );
							return results;
						}
					}

// Type selector
				} else if ( match[2] ) {
					push.apply( results, context.getElementsByTagName( selector ) );
					return results;

// Class selector
				} else if ( (m = match[3]) && support.getElementsByClassName &&
					context.getElementsByClassName ) {

push.apply( results, context.getElementsByClassName( m ) );
					return results;
				}
			}

// Take advantage of querySelectorAll
			if ( support.qsa &&
				!compilerCache[ selector + " " ] &&
				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {

if ( nodeType !== 1 ) {
					newContext = context;
					newSelector = selector;

// qSA looks outside Element context, which is not what we want
				// Thanks to Andrew Dupont for this workaround technique
				// Support: IE <=8
				// Exclude object elements
				} else if ( context.nodeName.toLowerCase() !== "object" ) {

// Capture the context ID, setting it first if necessary
					if ( (nid = context.getAttribute( "id" )) ) {
						nid = nid.replace( rcssescape, fcssescape );
					} else {
						context.setAttribute( "id", (nid = expando) );
					}

// Prefix every selector in the list
					groups = tokenize( selector );
					i = groups.length;
					while ( i-- ) {
						groups[i] = "#" + nid + " " + toSelector( groups[i] );
					}
					newSelector = groups.join( "," );

// Expand context for sibling selectors
					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
						context;
				}

if ( newSelector ) {
					try {
						push.apply( results,
							newContext.querySelectorAll( newSelector )
						);
						return results;
					} catch ( qsaError ) {
					} finally {
						if ( nid === expando ) {
							context.removeAttribute( "id" );
						}
					}
				}
			}
		}
	}

// All others
	return select( selector.replace( rtrim, "$1" ), context, results, seed );
}

/**
 * Create key-value caches of limited size
 * @returns {function(string, object)} Returns the Object data after storing it on itself with
 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
 *	deleting the oldest entry
 */
function createCache() {
	var keys = [];

function cache( key, value ) {
		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
		if ( keys.push( key + " " ) > Expr.cacheLength ) {
			// Only keep the most recent entries
			delete cache[ keys.shift() ];
		}
		return (cache[ key + " " ] = value);
	}
	return cache;
}

/**
 * Mark a function for special use by Sizzle
 * @param {Function} fn The function to mark
 */
function markFunction( fn ) {
	fn[ expando ] = true;
	return fn;
}

/**
 * Support testing using an element
 * @param {Function} fn Passed the created element and returns a boolean result
 */
function assert( fn ) {
	var el = document.createElement("fieldset");

try {
		return !!fn( el );
	} catch (e) {
		return false;
	} finally {
		// Remove from its parent by default
		if ( el.parentNode ) {
			el.parentNode.removeChild( el );
		}
		// release memory in IE
		el = null;
	}
}

/**
 * Adds the same handler for all of the specified attrs
 * @param {String} attrs Pipe-separated list of attributes
 * @param {Function} handler The method that will be applied
 */
function addHandle( attrs, handler ) {
	var arr = attrs.split("|"),
		i = arr.length;

while ( i-- ) {
		Expr.attrHandle[ arr[i] ] = handler;
	}
}

/**
 * Checks document order of two siblings
 * @param {Element} a
 * @param {Element} b
 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
 */
function siblingCheck( a, b ) {
	var cur = b && a,
		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
			a.sourceIndex - b.sourceIndex;

// Use IE sourceIndex if available on both nodes
	if ( diff ) {
		return diff;
	}

// Check if b follows a
	if ( cur ) {
		while ( (cur = cur.nextSibling) ) {
			if ( cur === b ) {
				return -1;
			}
		}
	}

return a ? 1 : -1;
}

/**
 * Returns a function to use in pseudos for input types
 * @param {String} type
 */
function createInputPseudo( type ) {
	return function( elem ) {
		var name = elem.nodeName.toLowerCase();
		return name === "input" && elem.type === type;
	};
}

/**
 * Returns a function to use in pseudos for buttons
 * @param {String} type
 */
function createButtonPseudo( type ) {
	return function( elem ) {
		var name = elem.nodeName.toLowerCase();
		return (name === "input" || name === "button") && elem.type === type;
	};
}

/**
 * Returns a function to use in pseudos for :enabled/:disabled
 * @param {Boolean} disabled true for :disabled; false for :enabled
 */
function createDisabledPseudo( disabled ) {
	// Known :disabled false positives:
	// IE: *[disabled]:not(button, input, select, textarea, optgroup, option, menuitem, fieldset)
	// not IE: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
	return function( elem ) {

// Check form elements and option elements for explicit disabling
		return "label" in elem && elem.disabled === disabled ||
			"form" in elem && elem.disabled === disabled ||

// Check non-disabled form elements for fieldset[disabled] ancestors
			"form" in elem && elem.disabled === false && (
				// Support: IE6-11+
				// Ancestry is covered for us
				elem.isDisabled === disabled ||

// Otherwise, assume any non-<option> under fieldset[disabled] is disabled
				/* jshint -W018 */
				elem.isDisabled !== !disabled &&
					("label" in elem || !disabledAncestor( elem )) !== disabled
			);
	};
}

/**
 * Returns a function to use in pseudos for positionals
 * @param {Function} fn
 */
function createPositionalPseudo( fn ) {
	return markFunction(function( argument ) {
		argument = +argument;
		return markFunction(function( seed, matches ) {
			var j,
				matchIndexes = fn( [], seed.length, argument ),
				i = matchIndexes.length;

// Match elements found at the specified indexes
			while ( i-- ) {
				if ( seed[ (j = matchIndexes[i]) ] ) {
					seed[j] = !(matches[j] = seed[j]);
				}
			}
		});
	});
}

/**
 * Checks a node for validity as a Sizzle context
 * @param {Element|Object=} context
 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
 */
function testContext( context ) {
	return context && typeof context.getElementsByTagName !== "undefined" && context;
}

// Expose support vars for convenience
support = Sizzle.support = {};

/**
 * Detects XML nodes
 * @param {Element|Object} elem An element or a document
 * @returns {Boolean} True iff elem is a non-HTML XML node
 */
isXML = Sizzle.isXML = function( elem ) {
	// documentElement is verified for cases where it doesn't yet exist
	// (such as loading iframes in IE - #4833)
	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
	return documentElement ? documentElement.nodeName !== "HTML" : false;
};

/**
 * Sets document-related variables once based on the current document
 * @param {Element|Object} [doc] An element or document object to use to set the document
 * @returns {Object} Returns the current document
 */
setDocument = Sizzle.setDocument = function( node ) {
	var hasCompare, subWindow,
		doc = node ? node.ownerDocument || node : preferredDoc;

// Return early if doc is invalid or already selected
	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
		return document;
	}

// Update global variables
	document = doc;
	docElem = document.documentElement;
	documentIsHTML = !isXML( document );

// Support: IE 9-11, Edge
	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
	if ( preferredDoc !== document &&
		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {

// Support: IE 11, Edge
		if ( subWindow.addEventListener ) {
			subWindow.addEventListener( "unload", unloadHandler, false );

// Support: IE 9 - 10 only
		} else if ( subWindow.attachEvent ) {
			subWindow.attachEvent( "onunload", unloadHandler );
		}
	}

/* Attributes
	---------------------------------------------------------------------- */

// Support: IE<8
	// Verify that getAttribute really returns attributes and not properties
	// (excepting IE8 booleans)
	support.attributes = assert(function( el ) {
		el.className = "i";
		return !el.getAttribute("className");
	});

/* getElement(s)By*
	---------------------------------------------------------------------- */

// Check if getElementsByTagName("*") returns only elements
	support.getElementsByTagName = assert(function( el ) {
		el.appendChild( document.createComment("") );
		return !el.getElementsByTagName("*").length;
	});

// Support: IE<9
	support.getElementsByClassName = rnative.test( document.getElementsByClassName );

// Support: IE<10
	// Check if getElementById returns elements by name
	// The broken getElementById methods don't pick up programmatically-set names,
	// so use a roundabout getElementsByName test
	support.getById = assert(function( el ) {
		docElem.appendChild( el ).id = expando;
		return !document.getElementsByName || !document.getElementsByName( expando ).length;
	});

// ID find and filter
	if ( support.getById ) {
		Expr.find["ID"] = function( id, context ) {
			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
				var m = context.getElementById( id );
				return m ? [ m ] : [];
			}
		};
		Expr.filter["ID"] = function( id ) {
			var attrId = id.replace( runescape, funescape );
			return function( elem ) {
				return elem.getAttribute("id") === attrId;
			};
		};
	} else {
		// Support: IE6/7
		// getElementById is not reliable as a find shortcut
		delete Expr.find["ID"];

Expr.filter["ID"] =  function( id ) {
			var attrId = id.replace( runescape, funescape );
			return function( elem ) {
				var node = typeof elem.getAttributeNode !== "undefined" &&
					elem.getAttributeNode("id");
				return node && node.value === attrId;
			};
		};
	}

// Tag
	Expr.find["TAG"] = support.getElementsByTagName ?
		function( tag, context ) {
			if ( typeof context.getElementsByTagName !== "undefined" ) {
				return context.getElementsByTagName( tag );

// DocumentFragment nodes don't have gEBTN
			} else if ( support.qsa ) {
				return context.querySelectorAll( tag );
			}
		} :

function( tag, context ) {
			var elem,
				tmp = [],
				i = 0,
				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
				results = context.getElementsByTagName( tag );

// Filter out possible comments
			if ( tag === "*" ) {
				while ( (elem = results[i++]) ) {
					if ( elem.nodeType === 1 ) {
						tmp.push( elem );
					}
				}

return tmp;
			}
			return results;
		};

// Class
	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
			return context.getElementsByClassName( className );
		}
	};

/* QSA/matchesSelector
	---------------------------------------------------------------------- */

// QSA and matchesSelector support

// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
	rbuggyMatches = [];

// qSa(:focus) reports false when true (Chrome 21)
	// We allow this because of a bug in IE8/9 that throws an error
	// whenever `document.activeElement` is accessed on an iframe
	// So, we allow :focus to pass through QSA all the time to avoid the IE error
	// See https://bugs.jquery.com/ticket/13378
	rbuggyQSA = [];

if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
		// Build QSA regex
		// Regex strategy adopted from Diego Perini
		assert(function( el ) {
			// Select is set to empty string on purpose
			// This is to test IE's treatment of not explicitly
			// setting a boolean content attribute,
			// since its presence should be enough
			// https://bugs.jquery.com/ticket/12359
			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
				"<option selected=''></option></select>";

// Support: IE8, Opera 11-12.16
			// Nothing should be selected when empty strings follow ^= or $= or *=
			// The test attribute must be unknown in Opera but "safe" for WinRT
			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
			}

// Support: IE8
			// Boolean attributes and "value" are not treated correctly
			if ( !el.querySelectorAll("[selected]").length ) {
				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
			}

// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
				rbuggyQSA.push("~=");
			}

// Webkit/Opera - :checked should return selected option elements
			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
			// IE8 throws error here and will not see later tests
			if ( !el.querySelectorAll(":checked").length ) {
				rbuggyQSA.push(":checked");
			}

// Support: Safari 8+, iOS 8+
			// https://bugs.webkit.org/show_bug.cgi?id=136851
			// In-page `selector#id sibling-combinator selector` fails
			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
				rbuggyQSA.push(".#.+[+~]");
			}
		});

assert(function( el ) {
			el.innerHTML = "<a href='' disabled='disabled'></a>" +
				"<select disabled='disabled'><option/></select>";

// Support: Windows 8 Native Apps
			// The type and name attributes are restricted during .innerHTML assignment
			var input = document.createElement("input");
			input.setAttribute( "type", "hidden" );
			el.appendChild( input ).setAttribute( "name", "D" );

// Support: IE8
			// Enforce case-sensitivity of name attribute
			if ( el.querySelectorAll("[name=d]").length ) {
				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
			}

// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
			// IE8 throws error here and will not see later tests
			if ( el.querySelectorAll(":enabled").length !== 2 ) {
				rbuggyQSA.push( ":enabled", ":disabled" );
			}

// Support: IE9-11+
			// IE's :disabled selector does not pick up the children of disabled fieldsets
			docElem.appendChild( el ).disabled = true;
			if ( el.querySelectorAll(":disabled").length !== 2 ) {
				rbuggyQSA.push( ":enabled", ":disabled" );
			}

// Opera 10-11 does not throw on post-comma invalid pseudos
			el.querySelectorAll("*,:x");
			rbuggyQSA.push(",.*:");
		});
	}

if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
		docElem.webkitMatchesSelector ||
		docElem.mozMatchesSelector ||
		docElem.oMatchesSelector ||
		docElem.msMatchesSelector) )) ) {

assert(function( el ) {
			// Check to see if it's possible to do matchesSelector
			// on a disconnected node (IE 9)
			support.disconnectedMatch = matches.call( el, "*" );

// This should fail with an exception
			// Gecko does not error, returns false instead
			matches.call( el, "[s!='']:x" );
			rbuggyMatches.push( "!=", pseudos );
		});
	}

rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );

/* Contains
	---------------------------------------------------------------------- */
	hasCompare = rnative.test( docElem.compareDocumentPosition );

// Element contains another
	// Purposefully self-exclusive
	// As in, an element does not contain itself
	contains = hasCompare || rnative.test( docElem.contains ) ?
		function( a, b ) {
			var adown = a.nodeType === 9 ? a.documentElement : a,
				bup = b && b.parentNode;
			return a === bup || !!( bup && bup.nodeType === 1 && (
				adown.contains ?
					adown.contains( bup ) :
					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
			));
		} :
		function( a, b ) {
			if ( b ) {
				while ( (b = b.parentNode) ) {
					if ( b === a ) {
						return true;
					}
				}
			}
			return false;
		};

/* Sorting
	---------------------------------------------------------------------- */

// Document order sorting
	sortOrder = hasCompare ?
	function( a, b ) {

// Flag for duplicate removal
		if ( a === b ) {
			hasDuplicate = true;
			return 0;
		}

// Sort on method existence if only one input has compareDocumentPosition
		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
		if ( compare ) {
			return compare;
		}

// Calculate position if both inputs belong to the same document
		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
			a.compareDocumentPosition( b ) :

// Otherwise we know they are disconnected
			1;

// Disconnected nodes
		if ( compare & 1 ||
			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {

// Choose the first element that is related to our preferred document
			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
				return -1;
			}
			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
				return 1;
			}

// Maintain original order
			return sortInput ?
				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
				0;
		}

return compare & 4 ? -1 : 1;
	} :
	function( a, b ) {
		// Exit early if the nodes are identical
		if ( a === b ) {
			hasDuplicate = true;
			return 0;
		}

var cur,
			i = 0,
			aup = a.parentNode,
			bup = b.parentNode,
			ap = [ a ],
			bp = [ b ];

// Parentless nodes are either documents or disconnected
		if ( !aup || !bup ) {
			return a === document ? -1 :
				b === document ? 1 :
				aup ? -1 :
				bup ? 1 :
				sortInput ?
				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
				0;

// If the nodes are siblings, we can do a quick check
		} else if ( aup === bup ) {
			return siblingCheck( a, b );
		}

// Otherwise we need full lists of their ancestors for comparison
		cur = a;
		while ( (cur = cur.parentNode) ) {
			ap.unshift( cur );
		}
		cur = b;
		while ( (cur = cur.parentNode) ) {
			bp.unshift( cur );
		}

// Walk down the tree looking for a discrepancy
		while ( ap[i] === bp[i] ) {
			i++;
		}

return i ?
			// Do a sibling check if the nodes have a common ancestor
			siblingCheck( ap[i], bp[i] ) :

// Otherwise nodes in our document sort first
			ap[i] === preferredDoc ? -1 :
			bp[i] === preferredDoc ? 1 :
			0;
	};

return document;
};

Sizzle.matches = function( expr, elements ) {
	return Sizzle( expr, null, null, elements );
};

Sizzle.matchesSelector = function( elem, expr ) {
	// Set document vars if needed
	if ( ( elem.ownerDocument || elem ) !== document ) {
		setDocument( elem );
	}

// Make sure that attribute selectors are quoted
	expr = expr.replace( rattributeQuotes, "='$1']" );

if ( support.matchesSelector && documentIsHTML &&
		!compilerCache[ expr + " " ] &&
		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {

try {
			var ret = matches.call( elem, expr );

// IE 9's matchesSelector returns false on disconnected nodes
			if ( ret || support.disconnectedMatch ||
					// As well, disconnected nodes are said to be in a document
					// fragment in IE 9
					elem.document && elem.document.nodeType !== 11 ) {
				return ret;
			}
		} catch (e) {}
	}

return Sizzle( expr, document, null, [ elem ] ).length > 0;
};

Sizzle.contains = function( context, elem ) {
	// Set document vars if needed
	if ( ( context.ownerDocument || context ) !== document ) {
		setDocument( context );
	}
	return contains( context, elem );
};

Sizzle.attr = function( elem, name ) {
	// Set document vars if needed
	if ( ( elem.ownerDocument || elem ) !== document ) {
		setDocument( elem );
	}

var fn = Expr.attrHandle[ name.toLowerCase() ],
		// Don't get fooled by Object.prototype properties (jQuery #13807)
		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
			fn( elem, name, !documentIsHTML ) :
			undefined;

return val !== undefined ?
		val :
		support.attributes || !documentIsHTML ?
			elem.getAttribute( name ) :
			(val = elem.getAttributeNode(name)) && val.specified ?
				val.value :
				null;
};

Sizzle.escape = function( sel ) {
	return (sel + "").replace( rcssescape, fcssescape );
};

Sizzle.error = function( msg ) {
	throw new Error( "Syntax error, unrecognized expression: " + msg );
};

/**
 * Document sorting and removing duplicates
 * @param {ArrayLike} results
 */
Sizzle.uniqueSort = function( results ) {
	var elem,
		duplicates = [],
		j = 0,
		i = 0;

// Unless we *know* we can detect duplicates, assume their presence
	hasDuplicate = !support.detectDuplicates;
	sortInput = !support.sortStable && results.slice( 0 );
	results.sort( sortOrder );

if ( hasDuplicate ) {
		while ( (elem = results[i++]) ) {
			if ( elem === results[ i ] ) {
				j = duplicates.push( i );
			}
		}
		while ( j-- ) {
			results.splice( duplicates[ j ], 1 );
		}
	}

// Clear input after sorting to release objects
	// See https://github.com/jquery/sizzle/pull/225
	sortInput = null;

return results;
};

/**
 * Utility function for retrieving the text value of an array of DOM nodes
 * @param {Array|Element} elem
 */
getText = Sizzle.getText = function( elem ) {
	var node,
		ret = "",
		i = 0,
		nodeType = elem.nodeType;

if ( !nodeType ) {
		// If no nodeType, this is expected to be an array
		while ( (node = elem[i++]) ) {
			// Do not traverse comment nodes
			ret += getText( node );
		}
	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
		// Use textContent for elements
		// innerText usage removed for consistency of new lines (jQuery #11153)
		if ( typeof elem.textContent === "string" ) {
			return elem.textContent;
		} else {
			// Traverse its children
			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
				ret += getText( elem );
			}
		}
	} else if ( nodeType === 3 || nodeType === 4 ) {
		return elem.nodeValue;
	}
	// Do not include comment or processing instruction nodes

return ret;
};

Expr = Sizzle.selectors = {

// Can be adjusted by the user
	cacheLength: 50,

createPseudo: markFunction,

match: matchExpr,

attrHandle: {},

find: {},

relative: {
		">": { dir: "parentNode", first: true },
		" ": { dir: "parentNode" },
		"+": { dir: "previousSibling", first: true },
		"~": { dir: "previousSibling" }
	},

preFilter: {
		"ATTR": function( match ) {
			match[1] = match[1].replace( runescape, funescape );

// Move the given value to match[3] whether quoted or unquoted
			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );

if ( match[2] === "~=" ) {
				match[3] = " " + match[3] + " ";
			}

return match.slice( 0, 4 );
		},

"CHILD": function( match ) {
			/* matches from matchExpr["CHILD"]
				1 type (only|nth|...)
				2 what (child|of-type)
				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
				4 xn-component of xn+y argument ([+-]?\d*n|)
				5 sign of xn-component
				6 x of xn-component
				7 sign of y-component
				8 y of y-component
			*/
			match[1] = match[1].toLowerCase();

if ( match[1].slice( 0, 3 ) === "nth" ) {
				// nth-* requires argument
				if ( !match[3] ) {
					Sizzle.error( match[0] );
				}

// numeric x and y parameters for Expr.filter.CHILD
				// remember that false/true cast respectively to 0/1
				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );

// other types prohibit arguments
			} else if ( match[3] ) {
				Sizzle.error( match[0] );
			}

return match;
		},

"PSEUDO": function( match ) {
			var excess,
				unquoted = !match[6] && match[2];

if ( matchExpr["CHILD"].test( match[0] ) ) {
				return null;
			}

// Accept quoted arguments as-is
			if ( match[3] ) {
				match[2] = match[4] || match[5] || "";

// Strip excess characters from unquoted arguments
			} else if ( unquoted && rpseudo.test( unquoted ) &&
				// Get excess from tokenize (recursively)
				(excess = tokenize( unquoted, true )) &&
				// advance to the next closing parenthesis
				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {

// excess is a negative index
				match[0] = match[0].slice( 0, excess );
				match[2] = unquoted.slice( 0, excess );
			}

// Return only captures needed by the pseudo filter method (type and argument)
			return match.slice( 0, 3 );
		}
	},

filter: {

"TAG": function( nodeNameSelector ) {
			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
			return nodeNameSelector === "*" ?
				function() { return true; } :
				function( elem ) {
					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
				};
		},

"CLASS": function( className ) {
			var pattern = classCache[ className + " " ];

return pattern ||
				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
				classCache( className, function( elem ) {
					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
				});
		},

"ATTR": function( name, operator, check ) {
			return function( elem ) {
				var result = Sizzle.attr( elem, name );

if ( result == null ) {
					return operator === "!=";
				}
				if ( !operator ) {
					return true;
				}

result += "";

return operator === "=" ? result === check :
					operator === "!=" ? result !== check :
					operator === "^=" ? check && result.indexOf( check ) === 0 :
					operator === "*=" ? check && result.indexOf( check ) > -1 :
					operator === "$=" ? check && result.slice( -check.length ) === check :
					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
					false;
			};
		},

"CHILD": function( type, what, argument, first, last ) {
			var simple = type.slice( 0, 3 ) !== "nth",
				forward = type.slice( -4 ) !== "last",
				ofType = what === "of-type";

return first === 1 && last === 0 ?

// Shortcut for :nth-*(n)
				function( elem ) {
					return !!elem.parentNode;
				} :

function( elem, context, xml ) {
					var cache, uniqueCache, outerCache, node, nodeIndex, start,
						dir = simple !== forward ? "nextSibling" : "previousSibling",
						parent = elem.parentNode,
						name = ofType && elem.nodeName.toLowerCase(),
						useCache = !xml && !ofType,
						diff = false;

if ( parent ) {

// :(first|last|only)-(child|of-type)
						if ( simple ) {
							while ( dir ) {
								node = elem;
								while ( (node = node[ dir ]) ) {
									if ( ofType ?
										node.nodeName.toLowerCase() === name :
										node.nodeType === 1 ) {

return false;
									}
								}
								// Reverse direction for :only-* (if we haven't yet done so)
								start = dir = type === "only" && !start && "nextSibling";
							}
							return true;
						}

start = [ forward ? parent.firstChild : parent.lastChild ];

// non-xml :nth-child(...) stores cache data on `parent`
						if ( forward && useCache ) {

// Seek `elem` from a previously-cached index

// ...in a gzip-friendly way
							node = parent;
							outerCache = node[ expando ] || (node[ expando ] = {});

// Support: IE <9 only
							// Defend against cloned attroperties (jQuery gh-1709)
							uniqueCache = outerCache[ node.uniqueID ] ||
								(outerCache[ node.uniqueID ] = {});

cache = uniqueCache[ type ] || [];
							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
							diff = nodeIndex && cache[ 2 ];
							node = nodeIndex && parent.childNodes[ nodeIndex ];

while ( (node = ++nodeIndex && node && node[ dir ] ||

// Fallback to seeking `elem` from the start
								(diff = nodeIndex = 0) || start.pop()) ) {

// When found, cache indexes on `parent` and break
								if ( node.nodeType === 1 && ++diff && node === elem ) {
									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
									break;
								}
							}

} else {
							// Use previously-cached element index if available
							if ( useCache ) {
								// ...in a gzip-friendly way
								node = elem;
								outerCache = node[ expando ] || (node[ expando ] = {});

// Support: IE <9 only
								// Defend against cloned attroperties (jQuery gh-1709)
								uniqueCache = outerCache[ node.uniqueID ] ||
									(outerCache[ node.uniqueID ] = {});

cache = uniqueCache[ type ] || [];
								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
								diff = nodeIndex;
							}

// xml :nth-child(...)
							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
							if ( diff === false ) {
								// Use the same loop as above to seek `elem` from the start
								while ( (node = ++nodeIndex && node && node[ dir ] ||
									(diff = nodeIndex = 0) || start.pop()) ) {

if ( ( ofType ?
										node.nodeName.toLowerCase() === name :
										node.nodeType === 1 ) &&
										++diff ) {

// Cache the index of each encountered element
										if ( useCache ) {
											outerCache = node[ expando ] || (node[ expando ] = {});

// Support: IE <9 only
											// Defend against cloned attroperties (jQuery gh-1709)
											uniqueCache = outerCache[ node.uniqueID ] ||
												(outerCache[ node.uniqueID ] = {});

uniqueCache[ type ] = [ dirruns, diff ];
										}

if ( node === elem ) {
											break;
										}
									}
								}
							}
						}

// Incorporate the offset, then check against cycle size
						diff -= last;
						return diff === first || ( diff % first === 0 && diff / first >= 0 );
					}
				};
		},

"PSEUDO": function( pseudo, argument ) {
			// pseudo-class names are case-insensitive
			// http://www.w3.org/TR/selectors/#pseudo-classes
			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
			// Remember that setFilters inherits from pseudos
			var args,
				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
					Sizzle.error( "unsupported pseudo: " + pseudo );

// The user may use createPseudo to indicate that
			// arguments are needed to create the filter function
			// just as Sizzle does
			if ( fn[ expando ] ) {
				return fn( argument );
			}

// But maintain support for old signatures
			if ( fn.length > 1 ) {
				args = [ pseudo, pseudo, "", argument ];
				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
					markFunction(function( seed, matches ) {
						var idx,
							matched = fn( seed, argument ),
							i = matched.length;
						while ( i-- ) {
							idx = indexOf( seed, matched[i] );
							seed[ idx ] = !( matches[ idx ] = matched[i] );
						}
					}) :
					function( elem ) {
						return fn( elem, 0, args );
					};
			}

return fn;
		}
	},

pseudos: {
		// Potentially complex pseudos
		"not": markFunction(function( selector ) {
			// Trim the selector passed to compile
			// to avoid treating leading and trailing
			// spaces as combinators
			var input = [],
				results = [],
				matcher = compile( selector.replace( rtrim, "$1" ) );

return matcher[ expando ] ?
				markFunction(function( seed, matches, context, xml ) {
					var elem,
						unmatched = matcher( seed, null, xml, [] ),
						i = seed.length;

// Match elements unmatched by `matcher`
					while ( i-- ) {
						if ( (elem = unmatched[i]) ) {
							seed[i] = !(matches[i] = elem);
						}
					}
				}) :
				function( elem, context, xml ) {
					input[0] = elem;
					matcher( input, null, xml, results );
					// Don't keep the element (issue #299)
					input[0] = null;
					return !results.pop();
				};
		}),

"has": markFunction(function( selector ) {
			return function( elem ) {
				return Sizzle( selector, elem ).length > 0;
			};
		}),

"contains": markFunction(function( text ) {
			text = text.replace( runescape, funescape );
			return function( elem ) {
				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
			};
		}),

// "Whether an element is represented by a :lang() selector
		// is based solely on the element's language value
		// being equal to the identifier C,
		// or beginning with the identifier C immediately followed by "-".
		// The matching of C against the element's language value is performed case-insensitively.
		// The identifier C does not have to be a valid language name."
		// http://www.w3.org/TR/selectors/#lang-pseudo
		"lang": markFunction( function( lang ) {
			// lang value must be a valid identifier
			if ( !ridentifier.test(lang || "") ) {
				Sizzle.error( "unsupported lang: " + lang );
			}
			lang = lang.replace( runescape, funescape ).toLowerCase();
			return function( elem ) {
				var elemLang;
				do {
					if ( (elemLang = documentIsHTML ?
						elem.lang :
						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {

elemLang = elemLang.toLowerCase();
						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
					}
				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
				return false;
			};
		}),

// Miscellaneous
		"target": function( elem ) {
			var hash = window.location && window.location.hash;
			return hash && hash.slice( 1 ) === elem.id;
		},

"root": function( elem ) {
			return elem === docElem;
		},

"focus": function( elem ) {
			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
		},

// Boolean properties
		"enabled": createDisabledPseudo( false ),
		"disabled": createDisabledPseudo( true ),

"checked": function( elem ) {
			// In CSS3, :checked should return both checked and selected elements
			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
			var nodeName = elem.nodeName.toLowerCase();
			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
		},

"selected": function( elem ) {
			// Accessing this property makes selected-by-default
			// options in Safari work properly
			if ( elem.parentNode ) {
				elem.parentNode.selectedIndex;
			}

return elem.selected === true;
		},

// Contents
		"empty": function( elem ) {
			// http://www.w3.org/TR/selectors/#empty-pseudo
			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
			//   but not by others (comment: 8; processing instruction: 7; etc.)
			// nodeType < 6 works because attributes (2) do not appear as children
			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
				if ( elem.nodeType < 6 ) {
					return false;
				}
			}
			return true;
		},

"parent": function( elem ) {
			return !Expr.pseudos["empty"]( elem );
		},

// Element/input types
		"header": function( elem ) {
			return rheader.test( elem.nodeName );
		},

"input": function( elem ) {
			return rinputs.test( elem.nodeName );
		},

"button": function( elem ) {
			var name = elem.nodeName.toLowerCase();
			return name === "input" && elem.type === "button" || name === "button";
		},

"text": function( elem ) {
			var attr;
			return elem.nodeName.toLowerCase() === "input" &&
				elem.type === "text" &&

// Support: IE<8
				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
		},

// Position-in-collection
		"first": createPositionalPseudo(function() {
			return [ 0 ];
		}),

"last": createPositionalPseudo(function( matchIndexes, length ) {
			return [ length - 1 ];
		}),

"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
			return [ argument < 0 ? argument + length : argument ];
		}),

"even": createPositionalPseudo(function( matchIndexes, length ) {
			var i = 0;
			for ( ; i < length; i += 2 ) {
				matchIndexes.push( i );
			}
			return matchIndexes;
		}),

"odd": createPositionalPseudo(function( matchIndexes, length ) {
			var i = 1;
			for ( ; i < length; i += 2 ) {
				matchIndexes.push( i );
			}
			return matchIndexes;
		}),

"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
			var i = argument < 0 ? argument + length : argument;
			for ( ; --i >= 0; ) {
				matchIndexes.push( i );
			}
			return matchIndexes;
		}),

"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
			var i = argument < 0 ? argument + length : argument;
			for ( ; ++i < length; ) {
				matchIndexes.push( i );
			}
			return matchIndexes;
		})
	}
};

Expr.pseudos["nth"] = Expr.pseudos["eq"];

// Add button/input type pseudos
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
	Expr.pseudos[ i ] = createInputPseudo( i );
}
for ( i in { submit: true, reset: true } ) {
	Expr.pseudos[ i ] = createButtonPseudo( i );
}

// Easy API for creating new setFilters
function setFilters() {}
setFilters.prototype = Expr.filters = Expr.pseudos;
Expr.setFilters = new setFilters();

tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
	var matched, match, tokens, type,
		soFar, groups, preFilters,
		cached = tokenCache[ selector + " " ];

if ( cached ) {
		return parseOnly ? 0 : cached.slice( 0 );
	}

soFar = selector;
	groups = [];
	preFilters = Expr.preFilter;

while ( soFar ) {

// Comma and first run
		if ( !matched || (match = rcomma.exec( soFar )) ) {
			if ( match ) {
				// Don't consume trailing commas as valid
				soFar = soFar.slice( match[0].length ) || soFar;
			}
			groups.push( (tokens = []) );
		}

matched = false;

// Combinators
		if ( (match = rcombinators.exec( soFar )) ) {
			matched = match.shift();
			tokens.push({
				value: matched,
				// Cast descendant combinators to space
				type: match[0].replace( rtrim, " " )
			});
			soFar = soFar.slice( matched.length );
		}

// Filters
		for ( type in Expr.filter ) {
			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
				(match = preFilters[ type ]( match ))) ) {
				matched = match.shift();
				tokens.push({
					value: matched,
					type: type,
					matches: match
				});
				soFar = soFar.slice( matched.length );
			}
		}

if ( !matched ) {
			break;
		}
	}

// Return the length of the invalid excess
	// if we're just parsing
	// Otherwise, throw an error or return tokens
	return parseOnly ?
		soFar.length :
		soFar ?
			Sizzle.error( selector ) :
			// Cache the tokens
			tokenCache( selector, groups ).slice( 0 );
};

function toSelector( tokens ) {
	var i = 0,
		len = tokens.length,
		selector = "";
	for ( ; i < len; i++ ) {
		selector += tokens[i].value;
	}
	return selector;
}

function addCombinator( matcher, combinator, base ) {
	var dir = combinator.dir,
		skip = combinator.next,
		key = skip || dir,
		checkNonElements = base && key === "parentNode",
		doneName = done++;

return combinator.first ?
		// Check against closest ancestor/preceding element
		function( elem, context, xml ) {
			while ( (elem = elem[ dir ]) ) {
				if ( elem.nodeType === 1 || checkNonElements ) {
					return matcher( elem, context, xml );
				}
			}
		} :

// Check against all ancestor/preceding elements
		function( elem, context, xml ) {
			var oldCache, uniqueCache, outerCache,
				newCache = [ dirruns, doneName ];

// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
			if ( xml ) {
				while ( (elem = elem[ dir ]) ) {
					if ( elem.nodeType === 1 || checkNonElements ) {
						if ( matcher( elem, context, xml ) ) {
							return true;
						}
					}
				}
			} else {
				while ( (elem = elem[ dir ]) ) {
					if ( elem.nodeType === 1 || checkNonElements ) {
						outerCache = elem[ expando ] || (elem[ expando ] = {});

// Support: IE <9 only
						// Defend against cloned attroperties (jQuery gh-1709)
						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});

if ( skip && skip === elem.nodeName.toLowerCase() ) {
							elem = elem[ dir ] || elem;
						} else if ( (oldCache = uniqueCache[ key ]) &&
							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {

// Assign to newCache so results back-propagate to previous elements
							return (newCache[ 2 ] = oldCache[ 2 ]);
						} else {
							// Reuse newcache so results back-propagate to previous elements
							uniqueCache[ key ] = newCache;

// A match means we're done; a fail means we have to keep checking
							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
								return true;
							}
						}
					}
				}
			}
		};
}

function multipleContexts( selector, contexts, results ) {
	var i = 0,
		len = contexts.length;
	for ( ; i < len; i++ ) {
		Sizzle( selector, contexts[i], results );
	}
	return results;
}

function condense( unmatched, map, filter, context, xml ) {
	var elem,
		newUnmatched = [],
		i = 0,
		len = unmatched.length,
		mapped = map != null;

for ( ; i < len; i++ ) {
		if ( (elem = unmatched[i]) ) {
			if ( !filter || filter( elem, context, xml ) ) {
				newUnmatched.push( elem );
				if ( mapped ) {
					map.push( i );
				}
			}
		}
	}

return newUnmatched;
}

function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
	if ( postFilter && !postFilter[ expando ] ) {
		postFilter = setMatcher( postFilter );
	}
	if ( postFinder && !postFinder[ expando ] ) {
		postFinder = setMatcher( postFinder, postSelector );
	}
	return markFunction(function( seed, results, context, xml ) {
		var temp, i, elem,
			preMap = [],
			postMap = [],
			preexisting = results.length,

// Get initial elements from seed or context
			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),

// Prefilter to get matcher input, preserving a map for seed-results synchronization
			matcherIn = preFilter && ( seed || !selector ) ?
				condense( elems, preMap, preFilter, context, xml ) :
				elems,

matcherOut = matcher ?
				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?

// ...intermediate processing is necessary
					[] :

// ...otherwise use results directly
					results :
				matcherIn;

// Find primary matches
		if ( matcher ) {
			matcher( matcherIn, matcherOut, context, xml );
		}

// Apply postFilter
		if ( postFilter ) {
			temp = condense( matcherOut, postMap );
			postFilter( temp, [], context, xml );

// Un-match failing elements by moving them back to matcherIn
			i = temp.length;
			while ( i-- ) {
				if ( (elem = temp[i]) ) {
					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
				}
			}
		}

if ( seed ) {
			if ( postFinder || preFilter ) {
				if ( postFinder ) {
					// Get the final matcherOut by condensing this intermediate into postFinder contexts
					temp = [];
					i = matcherOut.length;
					while ( i-- ) {
						if ( (elem = matcherOut[i]) ) {
							// Restore matcherIn since elem is not yet a final match
							temp.push( (matcherIn[i] = elem) );
						}
					}
					postFinder( null, (matcherOut = []), temp, xml );
				}

// Move matched elements from seed to results to keep them synchronized
				i = matcherOut.length;
				while ( i-- ) {
					if ( (elem = matcherOut[i]) &&
						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {

seed[temp] = !(results[temp] = elem);
					}
				}
			}

// Add elements to results, through postFinder if defined
		} else {
			matcherOut = condense(
				matcherOut === results ?
					matcherOut.splice( preexisting, matcherOut.length ) :
					matcherOut
			);
			if ( postFinder ) {
				postFinder( null, results, matcherOut, xml );
			} else {
				push.apply( results, matcherOut );
			}
		}
	});
}

function matcherFromTokens( tokens ) {
	var checkContext, matcher, j,
		len = tokens.length,
		leadingRelative = Expr.relative[ tokens[0].type ],
		implicitRelative = leadingRelative || Expr.relative[" "],
		i = leadingRelative ? 1 : 0,

// The foundational matcher ensures that elements are reachable from top-level context(s)
		matchContext = addCombinator( function( elem ) {
			return elem === checkContext;
		}, implicitRelative, true ),
		matchAnyContext = addCombinator( function( elem ) {
			return indexOf( checkContext, elem ) > -1;
		}, implicitRelative, true ),
		matchers = [ function( elem, context, xml ) {
			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
				(checkContext = context).nodeType ?
					matchContext( elem, context, xml ) :
					matchAnyContext( elem, context, xml ) );
			// Avoid hanging onto element (issue #299)
			checkContext = null;
			return ret;
		} ];

for ( ; i < len; i++ ) {
		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
		} else {
			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );

// Return special upon seeing a positional matcher
			if ( matcher[ expando ] ) {
				// Find the next relative operator (if any) for proper handling
				j = ++i;
				for ( ; j < len; j++ ) {
					if ( Expr.relative[ tokens[j].type ] ) {
						break;
					}
				}
				return setMatcher(
					i > 1 && elementMatcher( matchers ),
					i > 1 && toSelector(
						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
					).replace( rtrim, "$1" ),
					matcher,
					i < j && matcherFromTokens( tokens.slice( i, j ) ),
					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
					j < len && toSelector( tokens )
				);
			}
			matchers.push( matcher );
		}
	}

return elementMatcher( matchers );
}

function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
	var bySet = setMatchers.length > 0,
		byElement = elementMatchers.length > 0,
		superMatcher = function( seed, context, xml, results, outermost ) {
			var elem, j, matcher,
				matchedCount = 0,
				i = "0",
				unmatched = seed && [],
				setMatched = [],
				contextBackup = outermostContext,
				// We must always have either seed elements or outermost context
				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
				// Use integer dirruns iff this is the outermost matcher
				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
				len = elems.length;

if ( outermost ) {
				outermostContext = context === document || context || outermost;
			}

// Add elements passing elementMatchers directly to results
			// Support: IE<9, Safari
			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
				if ( byElement && elem ) {
					j = 0;
					if ( !context && elem.ownerDocument !== document ) {
						setDocument( elem );
						xml = !documentIsHTML;
					}
					while ( (matcher = elementMatchers[j++]) ) {
						if ( matcher( elem, context || document, xml) ) {
							results.push( elem );
							break;
						}
					}
					if ( outermost ) {
						dirruns = dirrunsUnique;
					}
				}

// Track unmatched elements for set filters
				if ( bySet ) {
					// They will have gone through all possible matchers
					if ( (elem = !matcher && elem) ) {
						matchedCount--;
					}

// Lengthen the array for every element, matched or not
					if ( seed ) {
						unmatched.push( elem );
					}
				}
			}

// `i` is now the count of elements visited above, and adding it to `matchedCount`
			// makes the latter nonnegative.
			matchedCount += i;

// Apply set filters to unmatched elements
			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
			// no element matchers and no seed.
			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
			// numerically zero.
			if ( bySet && i !== matchedCount ) {
				j = 0;
				while ( (matcher = setMatchers[j++]) ) {
					matcher( unmatched, setMatched, context, xml );
				}

if ( seed ) {
					// Reintegrate element matches to eliminate the need for sorting
					if ( matchedCount > 0 ) {
						while ( i-- ) {
							if ( !(unmatched[i] || setMatched[i]) ) {
								setMatched[i] = pop.call( results );
							}
						}
					}

// Discard index placeholder values to get only actual matches
					setMatched = condense( setMatched );
				}

// Add matches to results
				push.apply( results, setMatched );

// Seedless set matches succeeding multiple successful matchers stipulate sorting
				if ( outermost && !seed && setMatched.length > 0 &&
					( matchedCount + setMatchers.length ) > 1 ) {

Sizzle.uniqueSort( results );
				}
			}

// Override manipulation of globals by nested matchers
			if ( outermost ) {
				dirruns = dirrunsUnique;
				outermostContext = contextBackup;
			}

return unmatched;
		};

return bySet ?
		markFunction( superMatcher ) :
		superMatcher;
}

compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
	var i,
		setMatchers = [],
		elementMatchers = [],
		cached = compilerCache[ selector + " " ];

if ( !cached ) {
		// Generate a function of recursive functions that can be used to check each element
		if ( !match ) {
			match = tokenize( selector );
		}
		i = match.length;
		while ( i-- ) {
			cached = matcherFromTokens( match[i] );
			if ( cached[ expando ] ) {
				setMatchers.push( cached );
			} else {
				elementMatchers.push( cached );
			}
		}

// Cache the compiled function
		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );

// Save selector and tokenization
		cached.selector = selector;
	}
	return cached;
};

/**
 * A low-level selection function that works with Sizzle's compiled
 *  selector functions
 * @param {String|Function} selector A selector or a pre-compiled
 *  selector function built with Sizzle.compile
 * @param {Element} context
 * @param {Array} [results]
 * @param {Array} [seed] A set of elements to match against
 */
select = Sizzle.select = function( selector, context, results, seed ) {
	var i, tokens, token, type, find,
		compiled = typeof selector === "function" && selector,
		match = !seed && tokenize( (selector = compiled.selector || selector) );

results = results || [];

// Try to minimize operations if there is only one selector in the list and no seed
	// (the latter of which guarantees us context)
	if ( match.length === 1 ) {

// Reduce context if the leading compound selector is an ID
		tokens = match[0] = match[0].slice( 0 );
		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
				support.getById && context.nodeType === 9 && documentIsHTML &&
				Expr.relative[ tokens[1].type ] ) {

context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
			if ( !context ) {
				return results;

// Precompiled matchers will still verify ancestry, so step up a level
			} else if ( compiled ) {
				context = context.parentNode;
			}

selector = selector.slice( tokens.shift().value.length );
		}

// Fetch a seed set for right-to-left matching
		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
		while ( i-- ) {
			token = tokens[i];

// Abort if we hit a combinator
			if ( Expr.relative[ (type = token.type) ] ) {
				break;
			}
			if ( (find = Expr.find[ type ]) ) {
				// Search, expanding context for leading sibling combinators
				if ( (seed = find(
					token.matches[0].replace( runescape, funescape ),
					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
				)) ) {

// If seed is empty or no tokens remain, we can return early
					tokens.splice( i, 1 );
					selector = seed.length && toSelector( tokens );
					if ( !selector ) {
						push.apply( results, seed );
						return results;
					}

break;
				}
			}
		}
	}

// Compile and execute a filtering function if one is not provided
	// Provide `match` to avoid retokenization if we modified the selector above
	( compiled || compile( selector, match ) )(
		seed,
		context,
		!documentIsHTML,
		results,
		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
	);
	return results;
};

// One-time assignments

// Sort stability
support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;

// Support: Chrome 14-35+
// Always assume duplicates if they aren't passed to the comparison function
support.detectDuplicates = !!hasDuplicate;

// Initialize against the default document
setDocument();

// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
// Detached nodes confoundingly follow *each other*
support.sortDetached = assert(function( el ) {
	// Should return 1, but returns 4 (following)
	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
});

// Support: IE<8
// Prevent attribute/property "interpolation"
// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
if ( !assert(function( el ) {
	el.innerHTML = "<a href='#'></a>";
	return el.firstChild.getAttribute("href") === "#" ;
}) ) {
	addHandle( "type|href|height|width", function( elem, name, isXML ) {
		if ( !isXML ) {
			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
		}
	});
}

// Support: IE<9
// Use defaultValue in place of getAttribute("value")
if ( !support.attributes || !assert(function( el ) {
	el.innerHTML = "<input/>";
	el.firstChild.setAttribute( "value", "" );
	return el.firstChild.getAttribute( "value" ) === "";
}) ) {
	addHandle( "value", function( elem, name, isXML ) {
		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
			return elem.defaultValue;
		}
	});
}

// Support: IE<9
// Use getAttributeNode to fetch booleans when getAttribute lies
if ( !assert(function( el ) {
	return el.getAttribute("disabled") == null;
}) ) {
	addHandle( booleans, function( elem, name, isXML ) {
		var val;
		if ( !isXML ) {
			return elem[ name ] === true ? name.toLowerCase() :
					(val = elem.getAttributeNode( name )) && val.specified ?
					val.value :
				null;
		}
	});
}

return Sizzle;

})( window );

jQuery.find = Sizzle;
jQuery.expr = Sizzle.selectors;

// Deprecated
jQuery.expr[ ":" ] = jQuery.expr.pseudos;
jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
jQuery.text = Sizzle.getText;
jQuery.isXMLDoc = Sizzle.isXML;
jQuery.contains = Sizzle.contains;
jQuery.escapeSelector = Sizzle.escape;

var dir = function( elem, dir, until ) {
	var matched = [],
		truncate = until !== undefined;

while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
		if ( elem.nodeType === 1 ) {
			if ( truncate && jQuery( elem ).is( until ) ) {
				break;
			}
			matched.push( elem );
		}
	}
	return matched;
};

var siblings = function( n, elem ) {
	var matched = [];

for ( ; n; n = n.nextSibling ) {
		if ( n.nodeType === 1 && n !== elem ) {
			matched.push( n );
		}
	}

return matched;
};

var rneedsContext = jQuery.expr.match.needsContext;

var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );

var risSimple = /^.[^:#\[\.,]*$/;

// Implement the identical functionality for filter and not
function winnow( elements, qualifier, not ) {
	if ( jQuery.isFunction( qualifier ) ) {
		return jQuery.grep( elements, function( elem, i ) {
			return !!qualifier.call( elem, i, elem ) !== not;
		} );

}

if ( qualifier.nodeType ) {
		return jQuery.grep( elements, function( elem ) {
			return ( elem === qualifier ) !== not;
		} );

}

if ( typeof qualifier === "string" ) {
		if ( risSimple.test( qualifier ) ) {
			return jQuery.filter( qualifier, elements, not );
		}

qualifier = jQuery.filter( qualifier, elements );
	}

return jQuery.grep( elements, function( elem ) {
		return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
	} );
}

jQuery.filter = function( expr, elems, not ) {
	var elem = elems[ 0 ];

if ( not ) {
		expr = ":not(" + expr + ")";
	}

return elems.length === 1 && elem.nodeType === 1 ?
		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
			return elem.nodeType === 1;
		} ) );
};

jQuery.fn.extend( {
	find: function( selector ) {
		var i, ret,
			len = this.length,
			self = this;

if ( typeof selector !== "string" ) {
			return this.pushStack( jQuery( selector ).filter( function() {
				for ( i = 0; i < len; i++ ) {
					if ( jQuery.contains( self[ i ], this ) ) {
						return true;
					}
				}
			} ) );
		}

ret = this.pushStack( [] );

for ( i = 0; i < len; i++ ) {
			jQuery.find( selector, self[ i ], ret );
		}

return len > 1 ? jQuery.uniqueSort( ret ) : ret;
	},
	filter: function( selector ) {
		return this.pushStack( winnow( this, selector || [], false ) );
	},
	not: function( selector ) {
		return this.pushStack( winnow( this, selector || [], true ) );
	},
	is: function( selector ) {
		return !!winnow(
			this,

// If this is a positional/relative selector, check membership in the returned set
			// so $("p:first").is("p:last") won't return true for a doc with two "p".
			typeof selector === "string" && rneedsContext.test( selector ) ?
				jQuery( selector ) :
				selector || [],
			false
		).length;
	}
} );

// Initialize a jQuery object

// A central reference to the root jQuery(document)
var rootjQuery,

// A simple way to check for HTML strings
	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
	// Strict HTML recognition (#11290: must start with <)
	// Shortcut simple #id case for speed
	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,

init = jQuery.fn.init = function( selector, context, root ) {
		var match, elem;

// HANDLE: $(""), $(null), $(undefined), $(false)
		if ( !selector ) {
			return this;
		}

// Method init() accepts an alternate rootjQuery
		// so migrate can support jQuery.sub (gh-2101)
		root = root || rootjQuery;

// Handle HTML strings
		if ( typeof selector === "string" ) {
			if ( selector[ 0 ] === "<" &&
				selector[ selector.length - 1 ] === ">" &&
				selector.length >= 3 ) {

// Assume that strings that start and end with <> are HTML and skip the regex check
				match = [ null, selector, null ];

} else {
				match = rquickExpr.exec( selector );
			}

// Match html or make sure no context is specified for #id
			if ( match && ( match[ 1 ] || !context ) ) {

// HANDLE: $(html) -> $(array)
				if ( match[ 1 ] ) {
					context = context instanceof jQuery ? context[ 0 ] : context;

// Option to run scripts is true for back-compat
					// Intentionally let the error be thrown if parseHTML is not present
					jQuery.merge( this, jQuery.parseHTML(
						match[ 1 ],
						context && context.nodeType ? context.ownerDocument || context : document,
						true
					) );

// HANDLE: $(html, props)
					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
						for ( match in context ) {

// Properties of context are called as methods if possible
							if ( jQuery.isFunction( this[ match ] ) ) {
								this[ match ]( context[ match ] );

// ...and otherwise set as attributes
							} else {
								this.attr( match, context[ match ] );
							}
						}
					}

return this;

// HANDLE: $(#id)
				} else {
					elem = document.getElementById( match[ 2 ] );

if ( elem ) {

// Inject the element directly into the jQuery object
						this[ 0 ] = elem;
						this.length = 1;
					}
					return this;
				}

// HANDLE: $(expr, $(...))
			} else if ( !context || context.jquery ) {
				return ( context || root ).find( selector );

// HANDLE: $(expr, context)
			// (which is just equivalent to: $(context).find(expr)
			} else {
				return this.constructor( context ).find( selector );
			}

// HANDLE: $(DOMElement)
		} else if ( selector.nodeType ) {
			this[ 0 ] = selector;
			this.length = 1;
			return this;

// HANDLE: $(function)
		// Shortcut for document ready
		} else if ( jQuery.isFunction( selector ) ) {
			return root.ready !== undefined ?
				root.ready( selector ) :

// Execute immediately if ready is not present
				selector( jQuery );
		}

return jQuery.makeArray( selector, this );
	};

// Give the init function the jQuery prototype for later instantiation
init.prototype = jQuery.fn;

// Initialize central reference
rootjQuery = jQuery( document );

var rparentsprev = /^(?:parents|prev(?:Until|All))/,

// Methods guaranteed to produce a unique set when starting from a unique set
	guaranteedUnique = {
		children: true,
		contents: true,
		next: true,
		prev: true
	};

jQuery.fn.extend( {
	has: function( target ) {
		var targets = jQuery( target, this ),
			l = targets.length;

return this.filter( function() {
			var i = 0;
			for ( ; i < l; i++ ) {
				if ( jQuery.contains( this, targets[ i ] ) ) {
					return true;
				}
			}
		} );
	},

closest: function( selectors, context ) {
		var cur,
			i = 0,
			l = this.length,
			matched = [],
			targets = typeof selectors !== "string" && jQuery( selectors );

// Positional selectors never match, since there's no _selection_ context
		if ( !rneedsContext.test( selectors ) ) {
			for ( ; i < l; i++ ) {
				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {

// Always skip document fragments
					if ( cur.nodeType < 11 && ( targets ?
						targets.index( cur ) > -1 :

// Don't pass non-elements to Sizzle
						cur.nodeType === 1 &&
							jQuery.find.matchesSelector( cur, selectors ) ) ) {

matched.push( cur );
						break;
					}
				}
			}
		}

return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
	},

// Determine the position of an element within the set
	index: function( elem ) {

// No argument, return index in parent
		if ( !elem ) {
			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
		}

// Index in selector
		if ( typeof elem === "string" ) {
			return indexOf.call( jQuery( elem ), this[ 0 ] );
		}

// Locate the position of the desired element
		return indexOf.call( this,

// If it receives a jQuery object, the first element is used
			elem.jquery ? elem[ 0 ] : elem
		);
	},

add: function( selector, context ) {
		return this.pushStack(
			jQuery.uniqueSort(
				jQuery.merge( this.get(), jQuery( selector, context ) )
			)
		);
	},

addBack: function( selector ) {
		return this.add( selector == null ?
			this.prevObject : this.prevObject.filter( selector )
		);
	}
} );

function sibling( cur, dir ) {
	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
	return cur;
}

jQuery.each( {
	parent: function( elem ) {
		var parent = elem.parentNode;
		return parent && parent.nodeType !== 11 ? parent : null;
	},
	parents: function( elem ) {
		return dir( elem, "parentNode" );
	},
	parentsUntil: function( elem, i, until ) {
		return dir( elem, "parentNode", until );
	},
	next: function( elem ) {
		return sibling( elem, "nextSibling" );
	},
	prev: function( elem ) {
		return sibling( elem, "previousSibling" );
	},
	nextAll: function( elem ) {
		return dir( elem, "nextSibling" );
	},
	prevAll: function( elem ) {
		return dir( elem, "previousSibling" );
	},
	nextUntil: function( elem, i, until ) {
		return dir( elem, "nextSibling", until );
	},
	prevUntil: function( elem, i, until ) {
		return dir( elem, "previousSibling", until );
	},
	siblings: function( elem ) {
		return siblings( ( elem.parentNode || {} ).firstChild, elem );
	},
	children: function( elem ) {
		return siblings( elem.firstChild );
	},
	contents: function( elem ) {
		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
	}
}, function( name, fn ) {
	jQuery.fn[ name ] = function( until, selector ) {
		var matched = jQuery.map( this, fn, until );

if ( name.slice( -5 ) !== "Until" ) {
			selector = until;
		}

if ( selector && typeof selector === "string" ) {
			matched = jQuery.filter( selector, matched );
		}

if ( this.length > 1 ) {

// Remove duplicates
			if ( !guaranteedUnique[ name ] ) {
				jQuery.uniqueSort( matched );
			}

// Reverse order for parents* and prev-derivatives
			if ( rparentsprev.test( name ) ) {
				matched.reverse();
			}
		}

return this.pushStack( matched );
	};
} );
var rnotwhite = ( /\S+/g );

// Convert String-formatted options into Object-formatted ones
function createOptions( options ) {
	var object = {};
	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
		object[ flag ] = true;
	} );
	return object;
}

/*
 * Create a callback list using the following parameters:
 *
 *	options: an optional list of space-separated options that will change how
 *			the callback list behaves or a more traditional option object
 *
 * By default a callback list will act like an event callback list and can be
 * "fired" multiple times.
 *
 * Possible options:
 *
 *	once:			will ensure the callback list can only be fired once (like a Deferred)
 *
 *	memory:			will keep track of previous values and will call any callback added
 *					after the list has been fired right away with the latest "memorized"
 *					values (like a Deferred)
 *
 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
 *
 *	stopOnFalse:	interrupt callings when a callback returns false
 *
 */
jQuery.Callbacks = function( options ) {

// Convert options from String-formatted to Object-formatted if needed
	// (we check in cache first)
	options = typeof options === "string" ?
		createOptions( options ) :
		jQuery.extend( {}, options );

var // Flag to know if list is currently firing
		firing,

// Last fire value for non-forgettable lists
		memory,

// Flag to know if list was already fired
		fired,

// Flag to prevent firing
		locked,

// Actual callback list
		list = [],

// Queue of execution data for repeatable lists
		queue = [],

// Index of currently firing callback (modified by add/remove as needed)
		firingIndex = -1,

// Fire callbacks
		fire = function() {

// Enforce single-firing
			locked = options.once;

// Execute callbacks for all pending executions,
			// respecting firingIndex overrides and runtime changes
			fired = firing = true;
			for ( ; queue.length; firingIndex = -1 ) {
				memory = queue.shift();
				while ( ++firingIndex < list.length ) {

// Run callback and check for early termination
					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
						options.stopOnFalse ) {

// Jump to end and forget the data so .add doesn't re-fire
						firingIndex = list.length;
						memory = false;
					}
				}
			}

// Forget the data if we're done with it
			if ( !options.memory ) {
				memory = false;
			}

firing = false;

// Clean up if we're done firing for good
			if ( locked ) {

// Keep an empty list if we have data for future add calls
				if ( memory ) {
					list = [];

// Otherwise, this object is spent
				} else {
					list = "";
				}
			}
		},

// Actual Callbacks object
		self = {

// Add a callback or a collection of callbacks to the list
			add: function() {
				if ( list ) {

// If we have memory from a past run, we should fire after adding
					if ( memory && !firing ) {
						firingIndex = list.length - 1;
						queue.push( memory );
					}

( function add( args ) {
						jQuery.each( args, function( _, arg ) {
							if ( jQuery.isFunction( arg ) ) {
								if ( !options.unique || !self.has( arg ) ) {
									list.push( arg );
								}
							} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {

// Inspect recursively
								add( arg );
							}
						} );
					} )( arguments );

if ( memory && !firing ) {
						fire();
					}
				}
				return this;
			},

// Remove a callback from the list
			remove: function() {
				jQuery.each( arguments, function( _, arg ) {
					var index;
					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
						list.splice( index, 1 );

// Handle firing indexes
						if ( index <= firingIndex ) {
							firingIndex--;
						}
					}
				} );
				return this;
			},

// Check if a given callback is in the list.
			// If no argument is given, return whether or not list has callbacks attached.
			has: function( fn ) {
				return fn ?
					jQuery.inArray( fn, list ) > -1 :
					list.length > 0;
			},

// Remove all callbacks from the list
			empty: function() {
				if ( list ) {
					list = [];
				}
				return this;
			},

// Disable .fire and .add
			// Abort any current/pending executions
			// Clear all callbacks and values
			disable: function() {
				locked = queue = [];
				list = memory = "";
				return this;
			},
			disabled: function() {
				return !list;
			},

// Disable .fire
			// Also disable .add unless we have memory (since it would have no effect)
			// Abort any pending executions
			lock: function() {
				locked = queue = [];
				if ( !memory && !firing ) {
					list = memory = "";
				}
				return this;
			},
			locked: function() {
				return !!locked;
			},

// Call all callbacks with the given context and arguments
			fireWith: function( context, args ) {
				if ( !locked ) {
					args = args || [];
					args = [ context, args.slice ? args.slice() : args ];
					queue.push( args );
					if ( !firing ) {
						fire();
					}
				}
				return this;
			},

// Call all the callbacks with the given arguments
			fire: function() {
				self.fireWith( this, arguments );
				return this;
			},

// To know if the callbacks have already been called at least once
			fired: function() {
				return !!fired;
			}
		};

return self;
};

function Identity( v ) {
	return v;
}
function Thrower( ex ) {
	throw ex;
}

function adoptValue( value, resolve, reject ) {
	var method;

try {

// Check for promise aspect first to privilege synchronous behavior
		if ( value && jQuery.isFunction( ( method = value.promise ) ) ) {
			method.call( value ).done( resolve ).fail( reject );

// Other thenables
		} else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {
			method.call( value, resolve, reject );

// Other non-thenables
		} else {

// Support: Android 4.0 only
			// Strict mode functions invoked without .call/.apply get global-object context
			resolve.call( undefined, value );
		}

// For Promises/A+, convert exceptions into rejections
	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
	// Deferred#then to conditionally suppress rejection.
	} catch ( value ) {

// Support: Android 4.0 only
		// Strict mode functions invoked without .call/.apply get global-object context
		reject.call( undefined, value );
	}
}

jQuery.extend( {

Deferred: function( func ) {
		var tuples = [

// action, add listener, callbacks,
				// ... .then handlers, argument index, [final state]
				[ "notify", "progress", jQuery.Callbacks( "memory" ),
					jQuery.Callbacks( "memory" ), 2 ],
				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
			],
			state = "pending",
			promise = {
				state: function() {
					return state;
				},
				always: function() {
					deferred.done( arguments ).fail( arguments );
					return this;
				},
				"catch": function( fn ) {
					return promise.then( null, fn );
				},

// Keep pipe for back-compat
				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
					var fns = arguments;

return jQuery.Deferred( function( newDefer ) {
						jQuery.each( tuples, function( i, tuple ) {

// Map tuples (progress, done, fail) to arguments (done, fail, progress)
							var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];

// deferred.progress(function() { bind to newDefer or newDefer.notify })
							// deferred.done(function() { bind to newDefer or newDefer.resolve })
							// deferred.fail(function() { bind to newDefer or newDefer.reject })
							deferred[ tuple[ 1 ] ]( function() {
								var returned = fn && fn.apply( this, arguments );
								if ( returned && jQuery.isFunction( returned.promise ) ) {
									returned.promise()
										.progress( newDefer.notify )
										.done( newDefer.resolve )
										.fail( newDefer.reject );
								} else {
									newDefer[ tuple[ 0 ] + "With" ](
										this,
										fn ? [ returned ] : arguments
									);
								}
							} );
						} );
						fns = null;
					} ).promise();
				},
				then: function( onFulfilled, onRejected, onProgress ) {
					var maxDepth = 0;
					function resolve( depth, deferred, handler, special ) {
						return function() {
							var that = this,
								args = arguments,
								mightThrow = function() {
									var returned, then;

// Support: Promises/A+ section 2.3.3.3.3
									// https://promisesaplus.com/#point-59
									// Ignore double-resolution attempts
									if ( depth < maxDepth ) {
										return;
									}

returned = handler.apply( that, args );

// Support: Promises/A+ section 2.3.1
									// https://promisesaplus.com/#point-48
									if ( returned === deferred.promise() ) {
										throw new TypeError( "Thenable self-resolution" );
									}

// Support: Promises/A+ sections 2.3.3.1, 3.5
									// https://promisesaplus.com/#point-54
									// https://promisesaplus.com/#point-75
									// Retrieve `then` only once
									then = returned &&

// Support: Promises/A+ section 2.3.4
										// https://promisesaplus.com/#point-64
										// Only check objects and functions for thenability
										( typeof returned === "object" ||
											typeof returned === "function" ) &&
										returned.then;

// Handle a returned thenable
									if ( jQuery.isFunction( then ) ) {

// Special processors (notify) just wait for resolution
										if ( special ) {
											then.call(
												returned,
												resolve( maxDepth, deferred, Identity, special ),
												resolve( maxDepth, deferred, Thrower, special )
											);

// Normal processors (resolve) also hook into progress
										} else {

// ...and disregard older resolution values
											maxDepth++;

then.call(
												returned,
												resolve( maxDepth, deferred, Identity, special ),
												resolve( maxDepth, deferred, Thrower, special ),
												resolve( maxDepth, deferred, Identity,
													deferred.notifyWith )
											);
										}

// Handle all other returned values
									} else {

// Only substitute handlers pass on context
										// and multiple values (non-spec behavior)
										if ( handler !== Identity ) {
											that = undefined;
											args = [ returned ];
										}

// Process the value(s)
										// Default process is resolve
										( special || deferred.resolveWith )( that, args );
									}
								},

// Only normal processors (resolve) catch and reject exceptions
								process = special ?
									mightThrow :
									function() {
										try {
											mightThrow();
										} catch ( e ) {

if ( jQuery.Deferred.exceptionHook ) {
												jQuery.Deferred.exceptionHook( e,
													process.stackTrace );
											}

// Support: Promises/A+ section 2.3.3.3.4.1
											// https://promisesaplus.com/#point-61
											// Ignore post-resolution exceptions
											if ( depth + 1 >= maxDepth ) {

// Only substitute handlers pass on context
												// and multiple values (non-spec behavior)
												if ( handler !== Thrower ) {
													that = undefined;
													args = [ e ];
												}

deferred.rejectWith( that, args );
											}
										}
									};

// Support: Promises/A+ section 2.3.3.3.1
							// https://promisesaplus.com/#point-57
							// Re-resolve promises immediately to dodge false rejection from
							// subsequent errors
							if ( depth ) {
								process();
							} else {

// Call an optional hook to record the stack, in case of exception
								// since it's otherwise lost when execution goes async
								if ( jQuery.Deferred.getStackHook ) {
									process.stackTrace = jQuery.Deferred.getStackHook();
								}
								window.setTimeout( process );
							}
						};
					}

return jQuery.Deferred( function( newDefer ) {

// progress_handlers.add( ... )
						tuples[ 0 ][ 3 ].add(
							resolve(
								0,
								newDefer,
								jQuery.isFunction( onProgress ) ?
									onProgress :
									Identity,
								newDefer.notifyWith
							)
						);

// fulfilled_handlers.add( ... )
						tuples[ 1 ][ 3 ].add(
							resolve(
								0,
								newDefer,
								jQuery.isFunction( onFulfilled ) ?
									onFulfilled :
									Identity
							)
						);

// rejected_handlers.add( ... )
						tuples[ 2 ][ 3 ].add(
							resolve(
								0,
								newDefer,
								jQuery.isFunction( onRejected ) ?
									onRejected :
									Thrower
							)
						);
					} ).promise();
				},

// Get a promise for this deferred
				// If obj is provided, the promise aspect is added to the object
				promise: function( obj ) {
					return obj != null ? jQuery.extend( obj, promise ) : promise;
				}
			},
			deferred = {};

// Add list-specific methods
		jQuery.each( tuples, function( i, tuple ) {
			var list = tuple[ 2 ],
				stateString = tuple[ 5 ];

// promise.progress = list.add
			// promise.done = list.add
			// promise.fail = list.add
			promise[ tuple[ 1 ] ] = list.add;

// Handle state
			if ( stateString ) {
				list.add(
					function() {

// state = "resolved" (i.e., fulfilled)
						// state = "rejected"
						state = stateString;
					},

// rejected_callbacks.disable
					// fulfilled_callbacks.disable
					tuples[ 3 - i ][ 2 ].disable,

// progress_callbacks.lock
					tuples[ 0 ][ 2 ].lock
				);
			}

// progress_handlers.fire
			// fulfilled_handlers.fire
			// rejected_handlers.fire
			list.add( tuple[ 3 ].fire );

// deferred.notify = function() { deferred.notifyWith(...) }
			// deferred.resolve = function() { deferred.resolveWith(...) }
			// deferred.reject = function() { deferred.rejectWith(...) }
			deferred[ tuple[ 0 ] ] = function() {
				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
				return this;
			};

// deferred.notifyWith = list.fireWith
			// deferred.resolveWith = list.fireWith
			// deferred.rejectWith = list.fireWith
			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
		} );

// Make the deferred a promise
		promise.promise( deferred );

// Call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}

// All done!
		return deferred;
	},

// Deferred helper
	when: function( singleValue ) {
		var

// count of uncompleted subordinates
			remaining = arguments.length,

// count of unprocessed arguments
			i = remaining,

// subordinate fulfillment data
			resolveContexts = Array( i ),
			resolveValues = slice.call( arguments ),

// the master Deferred
			master = jQuery.Deferred(),

// subordinate callback factory
			updateFunc = function( i ) {
				return function( value ) {
					resolveContexts[ i ] = this;
					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
					if ( !( --remaining ) ) {
						master.resolveWith( resolveContexts, resolveValues );
					}
				};
			};

// Single- and empty arguments are adopted like Promise.resolve
		if ( remaining <= 1 ) {
			adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject );

// Use .then() to unwrap secondary thenables (cf. gh-3000)
			if ( master.state() === "pending" ||
				jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {

return master.then();
			}
		}

// Multiple arguments are aggregated like Promise.all array elements
		while ( i-- ) {
			adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
		}

return master.promise();
	}
} );

jQuery.Deferred.exceptionHook = function( error, stack ) {

// Support: IE 8 - 9 only
	// Console exists when dev tools are open, which can happen at any time
	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
		window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
	}
};

jQuery.readyException = function( error ) {
	window.setTimeout( function() {
		throw error;
	} );
};

// The deferred used on DOM ready
var readyList = jQuery.Deferred();

jQuery.fn.ready = function( fn ) {

readyList
		.then( fn )

// Wrap jQuery.readyException in a function so that the lookup
		// happens at the time of error handling instead of callback
		// registration.
		.catch( function( error ) {
			jQuery.readyException( error );
		} );

return this;
};

jQuery.extend( {

// Is the DOM ready to be used? Set to true once it occurs.
	isReady: false,

// A counter to track how many items to wait for before
	// the ready event fires. See #6781
	readyWait: 1,

// Hold (or release) the ready event
	holdReady: function( hold ) {
		if ( hold ) {
			jQuery.readyWait++;
		} else {
			jQuery.ready( true );
		}
	},

// Handle when the DOM is ready
	ready: function( wait ) {

// Abort if there are pending holds or we're already ready
		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
			return;
		}

// Remember that the DOM is ready
		jQuery.isReady = true;

// If a normal DOM Ready event fired, decrement, and wait if need be
		if ( wait !== true && --jQuery.readyWait > 0 ) {
			return;
		}

// If there are functions bound, to execute
		readyList.resolveWith( document, [ jQuery ] );
	}
} );

jQuery.ready.then = readyList.then;

// The ready event handler and self cleanup method
function completed() {
	document.removeEventListener( "DOMContentLoaded", completed );
	window.removeEventListener( "load", completed );
	jQuery.ready();
}

// Catch cases where $(document).ready() is called
// after the browser event has already occurred.
// Support: IE <=9 - 10 only
// Older IE sometimes signals "interactive" too soon
if ( document.readyState === "complete" ||
	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {

// Handle it asynchronously to allow scripts the opportunity to delay ready
	window.setTimeout( jQuery.ready );

} else {

// Use the handy event callback
	document.addEventListener( "DOMContentLoaded", completed );

// A fallback to window.onload, that will always work
	window.addEventListener( "load", completed );
}

// Multifunctional method to get and set values of a collection
// The value/s can optionally be executed if it's a function
var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
	var i = 0,
		len = elems.length,
		bulk = key == null;

// Sets many values
	if ( jQuery.type( key ) === "object" ) {
		chainable = true;
		for ( i in key ) {
			access( elems, fn, i, key[ i ], true, emptyGet, raw );
		}

// Sets one value
	} else if ( value !== undefined ) {
		chainable = true;

if ( !jQuery.isFunction( value ) ) {
			raw = true;
		}

if ( bulk ) {

// Bulk operations run against the entire set
			if ( raw ) {
				fn.call( elems, value );
				fn = null;

// ...except when executing function values
			} else {
				bulk = fn;
				fn = function( elem, key, value ) {
					return bulk.call( jQuery( elem ), value );
				};
			}
		}

if ( fn ) {
			for ( ; i < len; i++ ) {
				fn(
					elems[ i ], key, raw ?
					value :
					value.call( elems[ i ], i, fn( elems[ i ], key ) )
				);
			}
		}
	}

return chainable ?
		elems :

// Gets
		bulk ?
			fn.call( elems ) :
			len ? fn( elems[ 0 ], key ) : emptyGet;
};
var acceptData = function( owner ) {

// Accepts only:
	//  - Node
	//    - Node.ELEMENT_NODE
	//    - Node.DOCUMENT_NODE
	//  - Object
	//    - Any
	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
};

function Data() {
	this.expando = jQuery.expando + Data.uid++;
}

Data.uid = 1;

Data.prototype = {

cache: function( owner ) {

// Check if the owner object already has a cache
		var value = owner[ this.expando ];

// If not, create one
		if ( !value ) {
			value = {};

// We can accept data for non-element nodes in modern browsers,
			// but we should not, see #8335.
			// Always return an empty object.
			if ( acceptData( owner ) ) {

// If it is a node unlikely to be stringify-ed or looped over
				// use plain assignment
				if ( owner.nodeType ) {
					owner[ this.expando ] = value;

// Otherwise secure it in a non-enumerable property
				// configurable must be true to allow the property to be
				// deleted when data is removed
				} else {
					Object.defineProperty( owner, this.expando, {
						value: value,
						configurable: true
					} );
				}
			}
		}

return value;
	},
	set: function( owner, data, value ) {
		var prop,
			cache = this.cache( owner );

// Handle: [ owner, key, value ] args
		// Always use camelCase key (gh-2257)
		if ( typeof data === "string" ) {
			cache[ jQuery.camelCase( data ) ] = value;

// Handle: [ owner, { properties } ] args
		} else {

// Copy the properties one-by-one to the cache object
			for ( prop in data ) {
				cache[ jQuery.camelCase( prop ) ] = data[ prop ];
			}
		}
		return cache;
	},
	get: function( owner, key ) {
		return key === undefined ?
			this.cache( owner ) :

// Always use camelCase key (gh-2257)
			owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];
	},
	access: function( owner, key, value ) {

// In cases where either:
		//
		//   1. No key was specified
		//   2. A string key was specified, but no value provided
		//
		// Take the "read" path and allow the get method to determine
		// which value to return, respectively either:
		//
		//   1. The entire cache object
		//   2. The data stored at the key
		//
		if ( key === undefined ||
				( ( key && typeof key === "string" ) && value === undefined ) ) {

return this.get( owner, key );
		}

// When the key is not a string, or both a key and value
		// are specified, set or extend (existing objects) with either:
		//
		//   1. An object of properties
		//   2. A key and value
		//
		this.set( owner, key, value );

// Since the "set" path can have two possible entry points
		// return the expected data based on which path was taken[*]
		return value !== undefined ? value : key;
	},
	remove: function( owner, key ) {
		var i,
			cache = owner[ this.expando ];

if ( cache === undefined ) {
			return;
		}

if ( key !== undefined ) {

// Support array or space separated string of keys
			if ( jQuery.isArray( key ) ) {

// If key is an array of keys...
				// We always set camelCase keys, so remove that.
				key = key.map( jQuery.camelCase );
			} else {
				key = jQuery.camelCase( key );

// If a key with the spaces exists, use it.
				// Otherwise, create an array by matching non-whitespace
				key = key in cache ?
					[ key ] :
					( key.match( rnotwhite ) || [] );
			}

i = key.length;

while ( i-- ) {
				delete cache[ key[ i ] ];
			}
		}

// Remove the expando if there's no more data
		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {

// Support: Chrome <=35 - 45
			// Webkit & Blink performance suffers when deleting properties
			// from DOM nodes, so set to undefined instead
			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
			if ( owner.nodeType ) {
				owner[ this.expando ] = undefined;
			} else {
				delete owner[ this.expando ];
			}
		}
	},
	hasData: function( owner ) {
		var cache = owner[ this.expando ];
		return cache !== undefined && !jQuery.isEmptyObject( cache );
	}
};
var dataPriv = new Data();

var dataUser = new Data();

//	Implementation Summary
//
//	1. Enforce API surface and semantic compatibility with 1.9.x branch
//	2. Improve the module's maintainability by reducing the storage
//		paths to a single mechanism.
//	3. Use the same single mechanism to support "private" and "user" data.
//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
//	5. Avoid exposing implementation details on user objects (eg. expando properties)
//	6. Provide a clear path for implementation upgrade to WeakMap in 2014

var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
	rmultiDash = /[A-Z]/g;

function dataAttr( elem, key, data ) {
	var name;

// If nothing was found internally, try to fetch any
	// data from the HTML5 data-* attribute
	if ( data === undefined && elem.nodeType === 1 ) {
		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
		data = elem.getAttribute( name );

if ( typeof data === "string" ) {
			try {
				data = data === "true" ? true :
					data === "false" ? false :
					data === "null" ? null :

// Only convert to a number if it doesn't change the string
					+data + "" === data ? +data :
					rbrace.test( data ) ? JSON.parse( data ) :
					data;
			} catch ( e ) {}

// Make sure we set the data so it isn't changed later
			dataUser.set( elem, key, data );
		} else {
			data = undefined;
		}
	}
	return data;
}

jQuery.extend( {
	hasData: function( elem ) {
		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
	},

data: function( elem, name, data ) {
		return dataUser.access( elem, name, data );
	},

removeData: function( elem, name ) {
		dataUser.remove( elem, name );
	},

// TODO: Now that all calls to _data and _removeData have been replaced
	// with direct calls to dataPriv methods, these can be deprecated.
	_data: function( elem, name, data ) {
		return dataPriv.access( elem, name, data );
	},

_removeData: function( elem, name ) {
		dataPriv.remove( elem, name );
	}
} );

jQuery.fn.extend( {
	data: function( key, value ) {
		var i, name, data,
			elem = this[ 0 ],
			attrs = elem && elem.attributes;

// Gets all values
		if ( key === undefined ) {
			if ( this.length ) {
				data = dataUser.get( elem );

if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
					i = attrs.length;
					while ( i-- ) {

// Support: IE 11 only
						// The attrs elements can be null (#14894)
						if ( attrs[ i ] ) {
							name = attrs[ i ].name;
							if ( name.indexOf( "data-" ) === 0 ) {
								name = jQuery.camelCase( name.slice( 5 ) );
								dataAttr( elem, name, data[ name ] );
							}
						}
					}
					dataPriv.set( elem, "hasDataAttrs", true );
				}
			}

return data;
		}

// Sets multiple values
		if ( typeof key === "object" ) {
			return this.each( function() {
				dataUser.set( this, key );
			} );
		}

return access( this, function( value ) {
			var data;

// The calling jQuery object (element matches) is not empty
			// (and therefore has an element appears at this[ 0 ]) and the
			// `value` parameter was not undefined. An empty jQuery object
			// will result in `undefined` for elem = this[ 0 ] which will
			// throw an exception if an attempt to read a data cache is made.
			if ( elem && value === undefined ) {

// Attempt to get data from the cache
				// The key will always be camelCased in Data
				data = dataUser.get( elem, key );
				if ( data !== undefined ) {
					return data;
				}

// Attempt to "discover" the data in
				// HTML5 custom data-* attrs
				data = dataAttr( elem, key );
				if ( data !== undefined ) {
					return data;
				}

// We tried really hard, but the data doesn't exist.
				return;
			}

// Set the data...
			this.each( function() {

// We always store the camelCased key
				dataUser.set( this, key, value );
			} );
		}, null, value, arguments.length > 1, null, true );
	},

removeData: function( key ) {
		return this.each( function() {
			dataUser.remove( this, key );
		} );
	}
} );

jQuery.extend( {
	queue: function( elem, type, data ) {
		var queue;

if ( elem ) {
			type = ( type || "fx" ) + "queue";
			queue = dataPriv.get( elem, type );

// Speed up dequeue by getting out quickly if this is just a lookup
			if ( data ) {
				if ( !queue || jQuery.isArray( data ) ) {
					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
				} else {
					queue.push( data );
				}
			}
			return queue || [];
		}
	},

dequeue: function( elem, type ) {
		type = type || "fx";

var queue = jQuery.queue( elem, type ),
			startLength = queue.length,
			fn = queue.shift(),
			hooks = jQuery._queueHooks( elem, type ),
			next = function() {
				jQuery.dequeue( elem, type );
			};

// If the fx queue is dequeued, always remove the progress sentinel
		if ( fn === "inprogress" ) {
			fn = queue.shift();
			startLength--;
		}

if ( fn ) {

// Add a progress sentinel to prevent the fx queue from being
			// automatically dequeued
			if ( type === "fx" ) {
				queue.unshift( "inprogress" );
			}

// Clear up the last queue stop function
			delete hooks.stop;
			fn.call( elem, next, hooks );
		}

if ( !startLength && hooks ) {
			hooks.empty.fire();
		}
	},

// Not public - generate a queueHooks object, or return the current one
	_queueHooks: function( elem, type ) {
		var key = type + "queueHooks";
		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
			empty: jQuery.Callbacks( "once memory" ).add( function() {
				dataPriv.remove( elem, [ type + "queue", key ] );
			} )
		} );
	}
} );

jQuery.fn.extend( {
	queue: function( type, data ) {
		var setter = 2;

if ( typeof type !== "string" ) {
			data = type;
			type = "fx";
			setter--;
		}

if ( arguments.length < setter ) {
			return jQuery.queue( this[ 0 ], type );
		}

return data === undefined ?
			this :
			this.each( function() {
				var queue = jQuery.queue( this, type, data );

// Ensure a hooks for this queue
				jQuery._queueHooks( this, type );

if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
					jQuery.dequeue( this, type );
				}
			} );
	},
	dequeue: function( type ) {
		return this.each( function() {
			jQuery.dequeue( this, type );
		} );
	},
	clearQueue: function( type ) {
		return this.queue( type || "fx", [] );
	},

// Get a promise resolved when queues of a certain type
	// are emptied (fx is the type by default)
	promise: function( type, obj ) {
		var tmp,
			count = 1,
			defer = jQuery.Deferred(),
			elements = this,
			i = this.length,
			resolve = function() {
				if ( !( --count ) ) {
					defer.resolveWith( elements, [ elements ] );
				}
			};

if ( typeof type !== "string" ) {
			obj = type;
			type = undefined;
		}
		type = type || "fx";

while ( i-- ) {
			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
			if ( tmp && tmp.empty ) {
				count++;
				tmp.empty.add( resolve );
			}
		}
		resolve();
		return defer.promise( obj );
	}
} );
var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;

var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );

var cssExpand = [ "Top", "Right", "Bottom", "Left" ];

var isHiddenWithinTree = function( elem, el ) {

// isHiddenWithinTree might be called from jQuery#filter function;
		// in that case, element will be second argument
		elem = el || elem;

// Inline style trumps all
		return elem.style.display === "none" ||
			elem.style.display === "" &&

// Otherwise, check computed style
			// Support: Firefox <=43 - 45
			// Disconnected elements can have computed display: none, so first confirm that elem is
			// in the document.
			jQuery.contains( elem.ownerDocument, elem ) &&

jQuery.css( elem, "display" ) === "none";
	};

var swap = function( elem, options, callback, args ) {
	var ret, name,
		old = {};

// Remember the old values, and insert the new ones
	for ( name in options ) {
		old[ name ] = elem.style[ name ];
		elem.style[ name ] = options[ name ];
	}

ret = callback.apply( elem, args || [] );

// Revert the old values
	for ( name in options ) {
		elem.style[ name ] = old[ name ];
	}

return ret;
};

function adjustCSS( elem, prop, valueParts, tween ) {
	var adjusted,
		scale = 1,
		maxIterations = 20,
		currentValue = tween ?
			function() {
				return tween.cur();
			} :
			function() {
				return jQuery.css( elem, prop, "" );
			},
		initial = currentValue(),
		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),

// Starting value computation is required for potential unit mismatches
		initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
			rcssNum.exec( jQuery.css( elem, prop ) );

if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {

// Trust units reported by jQuery.css
		unit = unit || initialInUnit[ 3 ];

// Make sure we update the tween properties later on
		valueParts = valueParts || [];

// Iteratively approximate from a nonzero starting point
		initialInUnit = +initial || 1;

do {

// If previous iteration zeroed out, double until we get *something*.
			// Use string for doubling so we don't accidentally see scale as unchanged below
			scale = scale || ".5";

// Adjust and apply
			initialInUnit = initialInUnit / scale;
			jQuery.style( elem, prop, initialInUnit + unit );

// Update scale, tolerating zero or NaN from tween.cur()
		// Break the loop if scale is unchanged or perfect, or if we've just had enough.
		} while (
			scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
		);
	}

if ( valueParts ) {
		initialInUnit = +initialInUnit || +initial || 0;

// Apply relative offset (+=/-=) if specified
		adjusted = valueParts[ 1 ] ?
			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
			+valueParts[ 2 ];
		if ( tween ) {
			tween.unit = unit;
			tween.start = initialInUnit;
			tween.end = adjusted;
		}
	}
	return adjusted;
}

var defaultDisplayMap = {};

function getDefaultDisplay( elem ) {
	var temp,
		doc = elem.ownerDocument,
		nodeName = elem.nodeName,
		display = defaultDisplayMap[ nodeName ];

if ( display ) {
		return display;
	}

temp = doc.body.appendChild( doc.createElement( nodeName ) ),
	display = jQuery.css( temp, "display" );

temp.parentNode.removeChild( temp );

if ( display === "none" ) {
		display = "block";
	}
	defaultDisplayMap[ nodeName ] = display;

return display;
}

function showHide( elements, show ) {
	var display, elem,
		values = [],
		index = 0,
		length = elements.length;

// Determine new display value for elements that need to change
	for ( ; index < length; index++ ) {
		elem = elements[ index ];
		if ( !elem.style ) {
			continue;
		}

display = elem.style.display;
		if ( show ) {

// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
			// check is required in this first loop unless we have a nonempty display value (either
			// inline or about-to-be-restored)
			if ( display === "none" ) {
				values[ index ] = dataPriv.get( elem, "display" ) || null;
				if ( !values[ index ] ) {
					elem.style.display = "";
				}
			}
			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
				values[ index ] = getDefaultDisplay( elem );
			}
		} else {
			if ( display !== "none" ) {
				values[ index ] = "none";

// Remember what we're overwriting
				dataPriv.set( elem, "display", display );
			}
		}
	}

// Set the display of the elements in a second loop to avoid constant reflow
	for ( index = 0; index < length; index++ ) {
		if ( values[ index ] != null ) {
			elements[ index ].style.display = values[ index ];
		}
	}

return elements;
}

jQuery.fn.extend( {
	show: function() {
		return showHide( this, true );
	},
	hide: function() {
		return showHide( this );
	},
	toggle: function( state ) {
		if ( typeof state === "boolean" ) {
			return state ? this.show() : this.hide();
		}

return this.each( function() {
			if ( isHiddenWithinTree( this ) ) {
				jQuery( this ).show();
			} else {
				jQuery( this ).hide();
			}
		} );
	}
} );
var rcheckableType = ( /^(?:checkbox|radio)$/i );

var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );

var rscriptType = ( /^$|\/(?:java|ecma)script/i );

// We have to close these tags to support XHTML (#13200)
var wrapMap = {

// Support: IE <=9 only
	option: [ 1, "<select multiple='multiple'>", "</select>" ],

// XHTML parsers do not magically insert elements in the
	// same way that tag soup parsers do. So we cannot shorten
	// this by omitting <tbody> or other required elements.
	thead: [ 1, "<table>", "</table>" ],
	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],

_default: [ 0, "", "" ]
};

// Support: IE <=9 only
wrapMap.optgroup = wrapMap.option;

wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
wrapMap.th = wrapMap.td;

function getAll( context, tag ) {

// Support: IE <=9 - 11 only
	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
	var ret = typeof context.getElementsByTagName !== "undefined" ?
			context.getElementsByTagName( tag || "*" ) :
			typeof context.querySelectorAll !== "undefined" ?
				context.querySelectorAll( tag || "*" ) :
			[];

return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
		jQuery.merge( [ context ], ret ) :
		ret;
}

// Mark scripts as having already been evaluated
function setGlobalEval( elems, refElements ) {
	var i = 0,
		l = elems.length;

for ( ; i < l; i++ ) {
		dataPriv.set(
			elems[ i ],
			"globalEval",
			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
		);
	}
}

var rhtml = /<|&#?\w+;/;

function buildFragment( elems, context, scripts, selection, ignored ) {
	var elem, tmp, tag, wrap, contains, j,
		fragment = context.createDocumentFragment(),
		nodes = [],
		i = 0,
		l = elems.length;

for ( ; i < l; i++ ) {
		elem = elems[ i ];

if ( elem || elem === 0 ) {

// Add nodes directly
			if ( jQuery.type( elem ) === "object" ) {

// Support: Android <=4.0 only, PhantomJS 1 only
				// push.apply(_, arraylike) throws on ancient WebKit
				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );

// Convert non-html into a text node
			} else if ( !rhtml.test( elem ) ) {
				nodes.push( context.createTextNode( elem ) );

// Convert html into DOM nodes
			} else {
				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );

// Deserialize a standard representation
				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
				wrap = wrapMap[ tag ] || wrapMap._default;
				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];

// Descend through wrappers to the right content
				j = wrap[ 0 ];
				while ( j-- ) {
					tmp = tmp.lastChild;
				}

// Support: Android <=4.0 only, PhantomJS 1 only
				// push.apply(_, arraylike) throws on ancient WebKit
				jQuery.merge( nodes, tmp.childNodes );

// Remember the top-level container
				tmp = fragment.firstChild;

// Ensure the created nodes are orphaned (#12392)
				tmp.textContent = "";
			}
		}
	}

// Remove wrapper from fragment
	fragment.textContent = "";

i = 0;
	while ( ( elem = nodes[ i++ ] ) ) {

// Skip elements already in the context collection (trac-4087)
		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
			if ( ignored ) {
				ignored.push( elem );
			}
			continue;
		}

contains = jQuery.contains( elem.ownerDocument, elem );

// Append to fragment
		tmp = getAll( fragment.appendChild( elem ), "script" );

// Preserve script evaluation history
		if ( contains ) {
			setGlobalEval( tmp );
		}

// Capture executables
		if ( scripts ) {
			j = 0;
			while ( ( elem = tmp[ j++ ] ) ) {
				if ( rscriptType.test( elem.type || "" ) ) {
					scripts.push( elem );
				}
			}
		}
	}

return fragment;
}

( function() {
	var fragment = document.createDocumentFragment(),
		div = fragment.appendChild( document.createElement( "div" ) ),
		input = document.createElement( "input" );

// Support: Android 4.0 - 4.3 only
	// Check state lost if the name is set (#11217)
	// Support: Windows Web Apps (WWA)
	// `name` and `type` must use .setAttribute for WWA (#14901)
	input.setAttribute( "type", "radio" );
	input.setAttribute( "checked", "checked" );
	input.setAttribute( "name", "t" );

div.appendChild( input );

// Support: Android <=4.1 only
	// Older WebKit doesn't clone checked state correctly in fragments
	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;

// Support: IE <=11 only
	// Make sure textarea (and checkbox) defaultValue is properly cloned
	div.innerHTML = "<textarea>x</textarea>";
	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
} )();
var documentElement = document.documentElement;

function returnTrue() {
	return true;
}

function returnFalse() {
	return false;
}

// Support: IE <=9 only
// See #13393 for more info
function safeActiveElement() {
	try {
		return document.activeElement;
	} catch ( err ) { }
}

function on( elem, types, selector, data, fn, one ) {
	var origFn, type;

// Types can be a map of types/handlers
	if ( typeof types === "object" ) {

// ( types-Object, selector, data )
		if ( typeof selector !== "string" ) {

// ( types-Object, data )
			data = data || selector;
			selector = undefined;
		}
		for ( type in types ) {
			on( elem, type, selector, data, types[ type ], one );
		}
		return elem;
	}

if ( data == null && fn == null ) {

// ( types, fn )
		fn = selector;
		data = selector = undefined;
	} else if ( fn == null ) {
		if ( typeof selector === "string" ) {

// ( types, selector, fn )
			fn = data;
			data = undefined;
		} else {

// ( types, data, fn )
			fn = data;
			data = selector;
			selector = undefined;
		}
	}
	if ( fn === false ) {
		fn = returnFalse;
	} else if ( !fn ) {
		return elem;
	}

if ( one === 1 ) {
		origFn = fn;
		fn = function( event ) {

// Can use an empty set, since event contains the info
			jQuery().off( event );
			return origFn.apply( this, arguments );
		};

// Use same guid so caller can remove using origFn
		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
	}
	return elem.each( function() {
		jQuery.event.add( this, types, fn, data, selector );
	} );
}

/*
 * Helper functions for managing events -- not part of the public interface.
 * Props to Dean Edwards' addEvent library for many of the ideas.
 */
jQuery.event = {

global: {},

add: function( elem, types, handler, data, selector ) {

var handleObjIn, eventHandle, tmp,
			events, t, handleObj,
			special, handlers, type, namespaces, origType,
			elemData = dataPriv.get( elem );

// Don't attach events to noData or text/comment nodes (but allow plain objects)
		if ( !elemData ) {
			return;
		}

// Caller can pass in an object of custom data in lieu of the handler
		if ( handler.handler ) {
			handleObjIn = handler;
			handler = handleObjIn.handler;
			selector = handleObjIn.selector;
		}

// Ensure that invalid selectors throw exceptions at attach time
		// Evaluate against documentElement in case elem is a non-element node (e.g., document)
		if ( selector ) {
			jQuery.find.matchesSelector( documentElement, selector );
		}

// Make sure that the handler has a unique ID, used to find/remove it later
		if ( !handler.guid ) {
			handler.guid = jQuery.guid++;
		}

// Init the element's event structure and main handler, if this is the first
		if ( !( events = elemData.events ) ) {
			events = elemData.events = {};
		}
		if ( !( eventHandle = elemData.handle ) ) {
			eventHandle = elemData.handle = function( e ) {

// Discard the second event of a jQuery.event.trigger() and
				// when an event is called after a page has unloaded
				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
			};
		}

// Handle multiple events separated by a space
		types = ( types || "" ).match( rnotwhite ) || [ "" ];
		t = types.length;
		while ( t-- ) {
			tmp = rtypenamespace.exec( types[ t ] ) || [];
			type = origType = tmp[ 1 ];
			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();

// There *must* be a type, no attaching namespace-only handlers
			if ( !type ) {
				continue;
			}

// If event changes its type, use the special event handlers for the changed type
			special = jQuery.event.special[ type ] || {};

// If selector defined, determine special event api type, otherwise given type
			type = ( selector ? special.delegateType : special.bindType ) || type;

// Update special based on newly reset type
			special = jQuery.event.special[ type ] || {};

// handleObj is passed to all event handlers
			handleObj = jQuery.extend( {
				type: type,
				origType: origType,
				data: data,
				handler: handler,
				guid: handler.guid,
				selector: selector,
				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
				namespace: namespaces.join( "." )
			}, handleObjIn );

// Init the event handler queue if we're the first
			if ( !( handlers = events[ type ] ) ) {
				handlers = events[ type ] = [];
				handlers.delegateCount = 0;

// Only use addEventListener if the special events handler returns false
				if ( !special.setup ||
					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {

if ( elem.addEventListener ) {
						elem.addEventListener( type, eventHandle );
					}
				}
			}

if ( special.add ) {
				special.add.call( elem, handleObj );

if ( !handleObj.handler.guid ) {
					handleObj.handler.guid = handler.guid;
				}
			}

// Add to the element's handler list, delegates in front
			if ( selector ) {
				handlers.splice( handlers.delegateCount++, 0, handleObj );
			} else {
				handlers.push( handleObj );
			}

// Keep track of which events have ever been used, for event optimization
			jQuery.event.global[ type ] = true;
		}

// Detach an event or set of events from an element
	remove: function( elem, types, handler, selector, mappedTypes ) {

var j, origCount, tmp,
			events, t, handleObj,
			special, handlers, type, namespaces, origType,
			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );

if ( !elemData || !( events = elemData.events ) ) {
			return;
		}

// Once for each type.namespace in types; type may be omitted
		types = ( types || "" ).match( rnotwhite ) || [ "" ];
		t = types.length;
		while ( t-- ) {
			tmp = rtypenamespace.exec( types[ t ] ) || [];
			type = origType = tmp[ 1 ];
			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();

// Unbind all events (on this namespace, if provided) for the element
			if ( !type ) {
				for ( type in events ) {
					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
				}
				continue;
			}

special = jQuery.event.special[ type ] || {};
			type = ( selector ? special.delegateType : special.bindType ) || type;
			handlers = events[ type ] || [];
			tmp = tmp[ 2 ] &&
				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );

// Remove matching events
			origCount = j = handlers.length;
			while ( j-- ) {
				handleObj = handlers[ j ];

if ( ( mappedTypes || origType === handleObj.origType ) &&
					( !handler || handler.guid === handleObj.guid ) &&
					( !tmp || tmp.test( handleObj.namespace ) ) &&
					( !selector || selector === handleObj.selector ||
						selector === "**" && handleObj.selector ) ) {
					handlers.splice( j, 1 );

if ( handleObj.selector ) {
						handlers.delegateCount--;
					}
					if ( special.remove ) {
						special.remove.call( elem, handleObj );
					}
				}
			}

// Remove generic event handler if we removed something and no more handlers exist
			// (avoids potential for endless recursion during removal of special event handlers)
			if ( origCount && !handlers.length ) {
				if ( !special.teardown ||
					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {

jQuery.removeEvent( elem, type, elemData.handle );
				}

delete events[ type ];
			}
		}

// Remove data and the expando if it's no longer used
		if ( jQuery.isEmptyObject( events ) ) {
			dataPriv.remove( elem, "handle events" );
		}
	},

dispatch: function( nativeEvent ) {

// Make a writable jQuery.Event from the native event object
		var event = jQuery.event.fix( nativeEvent );

var i, j, ret, matched, handleObj, handlerQueue,
			args = new Array( arguments.length ),
			handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
			special = jQuery.event.special[ event.type ] || {};

// Use the fix-ed jQuery.Event rather than the (read-only) native event
		args[ 0 ] = event;

for ( i = 1; i < arguments.length; i++ ) {
			args[ i ] = arguments[ i ];
		}

event.delegateTarget = this;

// Call the preDispatch hook for the mapped type, and let it bail if desired
		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
			return;
		}

// Determine handlers
		handlerQueue = jQuery.event.handlers.call( this, event, handlers );

// Run delegates first; they may want to stop propagation beneath us
		i = 0;
		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
			event.currentTarget = matched.elem;

j = 0;
			while ( ( handleObj = matched.handlers[ j++ ] ) &&
				!event.isImmediatePropagationStopped() ) {

// Triggered event must either 1) have no namespace, or 2) have namespace(s)
				// a subset or equal to those in the bound event (both can have no namespace).
				if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {

event.handleObj = handleObj;
					event.data = handleObj.data;

ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
						handleObj.handler ).apply( matched.elem, args );

if ( ret !== undefined ) {
						if ( ( event.result = ret ) === false ) {
							event.preventDefault();
							event.stopPropagation();
						}
					}
				}
			}
		}

// Call the postDispatch hook for the mapped type
		if ( special.postDispatch ) {
			special.postDispatch.call( this, event );
		}

return event.result;
	},

handlers: function( event, handlers ) {
		var i, matches, sel, handleObj,
			handlerQueue = [],
			delegateCount = handlers.delegateCount,
			cur = event.target;

// Support: IE <=9
		// Find delegate handlers
		// Black-hole SVG <use> instance trees (#13180)
		//
		// Support: Firefox <=42
		// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
		if ( delegateCount && cur.nodeType &&
			( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {

for ( ; cur !== this; cur = cur.parentNode || this ) {

// Don't check non-elements (#13208)
				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
				if ( cur.nodeType === 1 && ( cur.disabled !== true || event.type !== "click" ) ) {
					matches = [];
					for ( i = 0; i < delegateCount; i++ ) {
						handleObj = handlers[ i ];

// Don't conflict with Object.prototype properties (#13203)
						sel = handleObj.selector + " ";

if ( matches[ sel ] === undefined ) {
							matches[ sel ] = handleObj.needsContext ?
								jQuery( sel, this ).index( cur ) > -1 :
								jQuery.find( sel, this, null, [ cur ] ).length;
						}
						if ( matches[ sel ] ) {
							matches.push( handleObj );
						}
					}
					if ( matches.length ) {
						handlerQueue.push( { elem: cur, handlers: matches } );
					}
				}
			}
		}

// Add the remaining (directly-bound) handlers
		if ( delegateCount < handlers.length ) {
			handlerQueue.push( { elem: this, handlers: handlers.slice( delegateCount ) } );
		}

return handlerQueue;
	},

addProp: function( name, hook ) {
		Object.defineProperty( jQuery.Event.prototype, name, {
			enumerable: true,
			configurable: true,

get: jQuery.isFunction( hook ) ?
				function() {
					if ( this.originalEvent ) {
							return hook( this.originalEvent );
					}
				} :
				function() {
					if ( this.originalEvent ) {
							return this.originalEvent[ name ];
					}
				},

set: function( value ) {
				Object.defineProperty( this, name, {
					enumerable: true,
					configurable: true,
					writable: true,
					value: value
				} );
			}
		} );
	},

fix: function( originalEvent ) {
		return originalEvent[ jQuery.expando ] ?
			originalEvent :
			new jQuery.Event( originalEvent );
	},

special: {
		load: {

// Prevent triggered image.load events from bubbling to window.load
			noBubble: true
		},
		focus: {

// Fire native event if possible so blur/focus sequence is correct
			trigger: function() {
				if ( this !== safeActiveElement() && this.focus ) {
					this.focus();
					return false;
				}
			},
			delegateType: "focusin"
		},
		blur: {
			trigger: function() {
				if ( this === safeActiveElement() && this.blur ) {
					this.blur();
					return false;
				}
			},
			delegateType: "focusout"
		},
		click: {

// For checkbox, fire native event so checked state will be right
			trigger: function() {
				if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
					this.click();
					return false;
				}
			},

// For cross-browser consistency, don't fire native .click() on links
			_default: function( event ) {
				return jQuery.nodeName( event.target, "a" );
			}
		},

beforeunload: {
			postDispatch: function( event ) {

// Support: Firefox 20+
				// Firefox doesn't alert if the returnValue field is not set.
				if ( event.result !== undefined && event.originalEvent ) {
					event.originalEvent.returnValue = event.result;
				}
			}
		}
	}
};

jQuery.removeEvent = function( elem, type, handle ) {

// This "if" is needed for plain objects
	if ( elem.removeEventListener ) {
		elem.removeEventListener( type, handle );
	}
};

jQuery.Event = function( src, props ) {

// Allow instantiation without the 'new' keyword
	if ( !( this instanceof jQuery.Event ) ) {
		return new jQuery.Event( src, props );
	}

// Event object
	if ( src && src.type ) {
		this.originalEvent = src;
		this.type = src.type;

// Events bubbling up the document may have been marked as prevented
		// by a handler lower down the tree; reflect the correct value.
		this.isDefaultPrevented = src.defaultPrevented ||
				src.defaultPrevented === undefined &&

// Support: Android <=2.3 only
				src.returnValue === false ?
			returnTrue :
			returnFalse;

// Create target properties
		// Support: Safari <=6 - 7 only
		// Target should not be a text node (#504, #13143)
		this.target = ( src.target && src.target.nodeType === 3 ) ?
			src.target.parentNode :
			src.target;

this.currentTarget = src.currentTarget;
		this.relatedTarget = src.relatedTarget;

// Event type
	} else {
		this.type = src;
	}

// Put explicitly provided properties onto the event object
	if ( props ) {
		jQuery.extend( this, props );
	}

// Create a timestamp if incoming event doesn't have one
	this.timeStamp = src && src.timeStamp || jQuery.now();

// Mark it as fixed
	this[ jQuery.expando ] = true;
};

// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jQuery.Event.prototype = {
	constructor: jQuery.Event,
	isDefaultPrevented: returnFalse,
	isPropagationStopped: returnFalse,
	isImmediatePropagationStopped: returnFalse,
	isSimulated: false,

preventDefault: function() {
		var e = this.originalEvent;

this.isDefaultPrevented = returnTrue;

if ( e && !this.isSimulated ) {
			e.preventDefault();
		}
	},
	stopPropagation: function() {
		var e = this.originalEvent;

this.isPropagationStopped = returnTrue;

if ( e && !this.isSimulated ) {
			e.stopPropagation();
		}
	},
	stopImmediatePropagation: function() {
		var e = this.originalEvent;

this.isImmediatePropagationStopped = returnTrue;

if ( e && !this.isSimulated ) {
			e.stopImmediatePropagation();
		}

this.stopPropagation();
	}
};

// Includes all common event props including KeyEvent and MouseEvent specific props
jQuery.each( {
	altKey: true,
	bubbles: true,
	cancelable: true,
	changedTouches: true,
	ctrlKey: true,
	detail: true,
	eventPhase: true,
	metaKey: true,
	pageX: true,
	pageY: true,
	shiftKey: true,
	view: true,
	"char": true,
	charCode: true,
	key: true,
	keyCode: true,
	button: true,
	buttons: true,
	clientX: true,
	clientY: true,
	offsetX: true,
	offsetY: true,
	pointerId: true,
	pointerType: true,
	screenX: true,
	screenY: true,
	targetTouches: true,
	toElement: true,
	touches: true,

which: function( event ) {
		var button = event.button;

// Add which for key events
		if ( event.which == null && rkeyEvent.test( event.type ) ) {
			return event.charCode != null ? event.charCode : event.keyCode;
		}

// Add which for click: 1 === left; 2 === middle; 3 === right
		if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
			return ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
		}

return event.which;
	}
}, jQuery.event.addProp );

// Create mouseenter/leave events using mouseover/out and event-time checks
// so that event delegation works in jQuery.
// Do the same for pointerenter/pointerleave and pointerover/pointerout
//
// Support: Safari 7 only
// Safari sends mouseenter too often; see:
// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
// for the description of the bug (it existed in older Chrome versions as well).
jQuery.each( {
	mouseenter: "mouseover",
	mouseleave: "mouseout",
	pointerenter: "pointerover",
	pointerleave: "pointerout"
}, function( orig, fix ) {
	jQuery.event.special[ orig ] = {
		delegateType: fix,
		bindType: fix,

handle: function( event ) {
			var ret,
				target = this,
				related = event.relatedTarget,
				handleObj = event.handleObj;

// For mouseenter/leave call the handler if related is outside the target.
			// NB: No relatedTarget if the mouse left/entered the browser window
			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
				event.type = handleObj.origType;
				ret = handleObj.handler.apply( this, arguments );
				event.type = fix;
			}
			return ret;
		}
	};
} );

jQuery.fn.extend( {

on: function( types, selector, data, fn ) {
		return on( this, types, selector, data, fn );
	},
	one: function( types, selector, data, fn ) {
		return on( this, types, selector, data, fn, 1 );
	},
	off: function( types, selector, fn ) {
		var handleObj, type;
		if ( types && types.preventDefault && types.handleObj ) {

// ( event )  dispatched jQuery.Event
			handleObj = types.handleObj;
			jQuery( types.delegateTarget ).off(
				handleObj.namespace ?
					handleObj.origType + "." + handleObj.namespace :
					handleObj.origType,
				handleObj.selector,
				handleObj.handler
			);
			return this;
		}
		if ( typeof types === "object" ) {

// ( types-object [, selector] )
			for ( type in types ) {
				this.off( type, selector, types[ type ] );
			}
			return this;
		}
		if ( selector === false || typeof selector === "function" ) {

// ( types [, fn] )
			fn = selector;
			selector = undefined;
		}
		if ( fn === false ) {
			fn = returnFalse;
		}
		return this.each( function() {
			jQuery.event.remove( this, types, fn, selector );
		} );
	}
} );

var

/* eslint-disable max-len */

/* eslint-enable */

// Support: IE <=10 - 11, Edge 12 - 13
	// In IE/Edge using regex groups here causes severe slowdowns.
	// See https://connect.microsoft.com/IE/feedback/details/1736512/
	rnoInnerhtml = /<script|<style|<link/i,

// checked="checked" or checked
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
	rscriptTypeMasked = /^true\/(.*)/,
	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;

function manipulationTarget( elem, content ) {
	if ( jQuery.nodeName( elem, "table" ) &&
		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {

return elem.getElementsByTagName( "tbody" )[ 0 ] || elem;
	}

return elem;
}

// Replace/restore the type attribute of script elements for safe DOM manipulation
function disableScript( elem ) {
	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
	return elem;
}
function restoreScript( elem ) {
	var match = rscriptTypeMasked.exec( elem.type );

if ( match ) {
		elem.type = match[ 1 ];
	} else {
		elem.removeAttribute( "type" );
	}

return elem;
}

function cloneCopyEvent( src, dest ) {
	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;

if ( dest.nodeType !== 1 ) {
		return;
	}

// 1. Copy private data: events, handlers, etc.
	if ( dataPriv.hasData( src ) ) {
		pdataOld = dataPriv.access( src );
		pdataCur = dataPriv.set( dest, pdataOld );
		events = pdataOld.events;

if ( events ) {
			delete pdataCur.handle;
			pdataCur.events = {};

for ( type in events ) {
				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
					jQuery.event.add( dest, type, events[ type ][ i ] );
				}
			}
		}
	}

// 2. Copy user data
	if ( dataUser.hasData( src ) ) {
		udataOld = dataUser.access( src );
		udataCur = jQuery.extend( {}, udataOld );

dataUser.set( dest, udataCur );
	}
}

// Fix IE bugs, see support tests
function fixInput( src, dest ) {
	var nodeName = dest.nodeName.toLowerCase();

// Fails to persist the checked state of a cloned checkbox or radio button.
	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
		dest.checked = src.checked;

// Fails to return the selected option to the default selected state when cloning options
	} else if ( nodeName === "input" || nodeName === "textarea" ) {
		dest.defaultValue = src.defaultValue;
	}
}

function domManip( collection, args, callback, ignored ) {

// Flatten any nested arrays
	args = concat.apply( [], args );

var fragment, first, scripts, hasScripts, node, doc,
		i = 0,
		l = collection.length,
		iNoClone = l - 1,
		value = args[ 0 ],
		isFunction = jQuery.isFunction( value );

// We can't cloneNode fragments that contain checked, in WebKit
	if ( isFunction ||
			( l > 1 && typeof value === "string" &&
				!support.checkClone && rchecked.test( value ) ) ) {
		return collection.each( function( index ) {
			var self = collection.eq( index );
			if ( isFunction ) {
				args[ 0 ] = value.call( this, index, self.html() );
			}
			domManip( self, args, callback, ignored );
		} );
	}

if ( l ) {
		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
		first = fragment.firstChild;

if ( fragment.childNodes.length === 1 ) {
			fragment = first;
		}

// Require either new content or an interest in ignored elements to invoke the callback
		if ( first || ignored ) {
			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
			hasScripts = scripts.length;

// Use the original fragment for the last item
			// instead of the first because it can end up
			// being emptied incorrectly in certain situations (#8070).
			for ( ; i < l; i++ ) {
				node = fragment;

if ( i !== iNoClone ) {
					node = jQuery.clone( node, true, true );

// Keep references to cloned scripts for later restoration
					if ( hasScripts ) {

// Support: Android <=4.0 only, PhantomJS 1 only
						// push.apply(_, arraylike) throws on ancient WebKit
						jQuery.merge( scripts, getAll( node, "script" ) );
					}
				}

callback.call( collection[ i ], node, i );
			}

if ( hasScripts ) {
				doc = scripts[ scripts.length - 1 ].ownerDocument;

// Reenable scripts
				jQuery.map( scripts, restoreScript );

// Evaluate executable scripts on first document insertion
				for ( i = 0; i < hasScripts; i++ ) {
					node = scripts[ i ];
					if ( rscriptType.test( node.type || "" ) &&
						!dataPriv.access( node, "globalEval" ) &&
						jQuery.contains( doc, node ) ) {

if ( node.src ) {

// Optional AJAX dependency, but won't run scripts if not present
							if ( jQuery._evalUrl ) {
								jQuery._evalUrl( node.src );
							}
						} else {
							DOMEval( node.textContent.replace( rcleanScript, "" ), doc );
						}
					}
				}
			}
		}
	}

return collection;
}

function remove( elem, selector, keepData ) {
	var node,
		nodes = selector ? jQuery.filter( selector, elem ) : elem,
		i = 0;

for ( ; ( node = nodes[ i ] ) != null; i++ ) {
		if ( !keepData && node.nodeType === 1 ) {
			jQuery.cleanData( getAll( node ) );
		}

if ( node.parentNode ) {
			if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
				setGlobalEval( getAll( node, "script" ) );
			}
			node.parentNode.removeChild( node );
		}
	}

return elem;
}

jQuery.extend( {
	htmlPrefilter: function( html ) {
		return html.replace( rxhtmlTag, "<$1></$2>" );
	},

clone: function( elem, dataAndEvents, deepDataAndEvents ) {
		var i, l, srcElements, destElements,
			clone = elem.cloneNode( true ),
			inPage = jQuery.contains( elem.ownerDocument, elem );

// Fix IE cloning issues
		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
				!jQuery.isXMLDoc( elem ) ) {

// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
			destElements = getAll( clone );
			srcElements = getAll( elem );

for ( i = 0, l = srcElements.length; i < l; i++ ) {
				fixInput( srcElements[ i ], destElements[ i ] );
			}
		}

// Copy the events from the original to the clone
		if ( dataAndEvents ) {
			if ( deepDataAndEvents ) {
				srcElements = srcElements || getAll( elem );
				destElements = destElements || getAll( clone );

for ( i = 0, l = srcElements.length; i < l; i++ ) {
					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
				}
			} else {
				cloneCopyEvent( elem, clone );
			}
		}

// Preserve script evaluation history
		destElements = getAll( clone, "script" );
		if ( destElements.length > 0 ) {
			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
		}

// Return the cloned set
		return clone;
	},

cleanData: function( elems ) {
		var data, elem, type,
			special = jQuery.event.special,
			i = 0;

for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
			if ( acceptData( elem ) ) {
				if ( ( data = elem[ dataPriv.expando ] ) ) {
					if ( data.events ) {
						for ( type in data.events ) {
							if ( special[ type ] ) {
								jQuery.event.remove( elem, type );

// This is a shortcut to avoid jQuery.event.remove's overhead
							} else {
								jQuery.removeEvent( elem, type, data.handle );
							}
						}
					}

// Support: Chrome <=35 - 45+
					// Assign undefined instead of using delete, see Data#remove
					elem[ dataPriv.expando ] = undefined;
				}
				if ( elem[ dataUser.expando ] ) {

// Support: Chrome <=35 - 45+
					// Assign undefined instead of using delete, see Data#remove
					elem[ dataUser.expando ] = undefined;
				}
			}
		}
	}
} );

jQuery.fn.extend( {
	detach: function( selector ) {
		return remove( this, selector, true );
	},

remove: function( selector ) {
		return remove( this, selector );
	},

text: function( value ) {
		return access( this, function( value ) {
			return value === undefined ?
				jQuery.text( this ) :
				this.empty().each( function() {
					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
						this.textContent = value;
					}
				} );
		}, null, value, arguments.length );
	},

append: function() {
		return domManip( this, arguments, function( elem ) {
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
				var target = manipulationTarget( this, elem );
				target.appendChild( elem );
			}
		} );
	},

prepend: function() {
		return domManip( this, arguments, function( elem ) {
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
				var target = manipulationTarget( this, elem );
				target.insertBefore( elem, target.firstChild );
			}
		} );
	},

before: function() {
		return domManip( this, arguments, function( elem ) {
			if ( this.parentNode ) {
				this.parentNode.insertBefore( elem, this );
			}
		} );
	},

after: function() {
		return domManip( this, arguments, function( elem ) {
			if ( this.parentNode ) {
				this.parentNode.insertBefore( elem, this.nextSibling );
			}
		} );
	},

empty: function() {
		var elem,
			i = 0;

for ( ; ( elem = this[ i ] ) != null; i++ ) {
			if ( elem.nodeType === 1 ) {

// Prevent memory leaks
				jQuery.cleanData( getAll( elem, false ) );

// Remove any remaining nodes
				elem.textContent = "";
			}
		}

return this;
	},

clone: function( dataAndEvents, deepDataAndEvents ) {
		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

return this.map( function() {
			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
		} );
	},

html: function( value ) {
		return access( this, function( value ) {
			var elem = this[ 0 ] || {},
				i = 0,
				l = this.length;

if ( value === undefined && elem.nodeType === 1 ) {
				return elem.innerHTML;
			}

// See if we can take a shortcut and just use innerHTML
			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {

value = jQuery.htmlPrefilter( value );

try {
					for ( ; i < l; i++ ) {
						elem = this[ i ] || {};

// Remove element nodes and prevent memory leaks
						if ( elem.nodeType === 1 ) {
							jQuery.cleanData( getAll( elem, false ) );
							elem.innerHTML = value;
						}
					}

elem = 0;

// If using innerHTML throws an exception, use the fallback method
				} catch ( e ) {}
			}

if ( elem ) {
				this.empty().append( value );
			}
		}, null, value, arguments.length );
	},

replaceWith: function() {
		var ignored = [];

// Make the changes, replacing each non-ignored context element with the new content
		return domManip( this, arguments, function( elem ) {
			var parent = this.parentNode;

if ( jQuery.inArray( this, ignored ) < 0 ) {
				jQuery.cleanData( getAll( this ) );
				if ( parent ) {
					parent.replaceChild( elem, this );
				}
			}

// Force callback invocation
		}, ignored );
	}
} );

jQuery.each( {
	appendTo: "append",
	prependTo: "prepend",
	insertBefore: "before",
	insertAfter: "after",
	replaceAll: "replaceWith"
}, function( name, original ) {
	jQuery.fn[ name ] = function( selector ) {
		var elems,
			ret = [],
			insert = jQuery( selector ),
			last = insert.length - 1,
			i = 0;

for ( ; i <= last; i++ ) {
			elems = i === last ? this : this.clone( true );
			jQuery( insert[ i ] )[ original ]( elems );

// Support: Android <=4.0 only, PhantomJS 1 only
			// .get() because push.apply(_, arraylike) throws on ancient WebKit
			push.apply( ret, elems.get() );
		}

return this.pushStack( ret );
	};
} );
var rmargin = ( /^margin/ );

var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );

var getStyles = function( elem ) {

// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
		// IE throws on elements created in popups
		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
		var view = elem.ownerDocument.defaultView;

if ( !view || !view.opener ) {
			view = window;
		}

return view.getComputedStyle( elem );
	};

( function() {

// Executing both pixelPosition & boxSizingReliable tests require only one layout
	// so they're executed at the same time to save the second computation.
	function computeStyleTests() {

// This is a singleton, we need to execute it only once
		if ( !div ) {
			return;
		}

div.style.cssText =
			"box-sizing:border-box;" +
			"position:relative;display:block;" +
			"margin:auto;border:1px;padding:1px;" +
			"top:1%;width:50%";
		div.innerHTML = "";
		documentElement.appendChild( container );

var divStyle = window.getComputedStyle( div );
		pixelPositionVal = divStyle.top !== "1%";

// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
		reliableMarginLeftVal = divStyle.marginLeft === "2px";
		boxSizingReliableVal = divStyle.width === "4px";

// Support: Android 4.0 - 4.3 only
		// Some styles come back with percentage values, even though they shouldn't
		div.style.marginRight = "50%";
		pixelMarginRightVal = divStyle.marginRight === "4px";

documentElement.removeChild( container );

// Nullify the div so it wouldn't be stored in the memory and
		// it will also be a sign that checks already performed
		div = null;
	}

var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
		container = document.createElement( "div" ),
		div = document.createElement( "div" );

// Finish early in limited (non-browser) environments
	if ( !div.style ) {
		return;
	}

// Support: IE <=9 - 11 only
	// Style of cloned element affects source element cloned (#8908)
	div.style.backgroundClip = "content-box";
	div.cloneNode( true ).style.backgroundClip = "";
	support.clearCloneStyle = div.style.backgroundClip === "content-box";

container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
		"padding:0;margin-top:1px;position:absolute";
	container.appendChild( div );

jQuery.extend( support, {
		pixelPosition: function() {
			computeStyleTests();
			return pixelPositionVal;
		},
		boxSizingReliable: function() {
			computeStyleTests();
			return boxSizingReliableVal;
		},
		pixelMarginRight: function() {
			computeStyleTests();
			return pixelMarginRightVal;
		},
		reliableMarginLeft: function() {
			computeStyleTests();
			return reliableMarginLeftVal;
		}
	} );
} )();

function curCSS( elem, name, computed ) {
	var width, minWidth, maxWidth, ret,
		style = elem.style;

computed = computed || getStyles( elem );

// Support: IE <=9 only
	// getPropertyValue is only needed for .css('filter') (#12537)
	if ( computed ) {
		ret = computed.getPropertyValue( name ) || computed[ name ];

if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
			ret = jQuery.style( elem, name );
		}

// A tribute to the "awesome hack by Dean Edwards"
		// Android Browser returns percentage for some values,
		// but width seems to be reliably pixels.
		// This is against the CSSOM draft spec:
		// https://drafts.csswg.org/cssom/#resolved-values
		if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {

// Remember the original values
			width = style.width;
			minWidth = style.minWidth;
			maxWidth = style.maxWidth;

// Put in the new values to get a computed value out
			style.minWidth = style.maxWidth = style.width = ret;
			ret = computed.width;

// Revert the changed values
			style.width = width;
			style.minWidth = minWidth;
			style.maxWidth = maxWidth;
		}
	}

return ret !== undefined ?

// Support: IE <=9 - 11 only
		// IE returns zIndex value as an integer.
		ret + "" :
		ret;
}

function addGetHookIf( conditionFn, hookFn ) {

// Define the hook, we'll check on the first run if it's really needed.
	return {
		get: function() {
			if ( conditionFn() ) {

// Hook not needed (or it's not possible to use it due
				// to missing dependency), remove it.
				delete this.get;
				return;
			}

// Hook needed; redefine it so that the support test is not executed again.
			return ( this.get = hookFn ).apply( this, arguments );
		}
	};
}

var

// Swappable if display is none or starts with table
	// except "table", "table-cell", or "table-caption"
	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
	cssNormalTransform = {
		letterSpacing: "0",
		fontWeight: "400"
	},

cssPrefixes = [ "Webkit", "Moz", "ms" ],
	emptyStyle = document.createElement( "div" ).style;

// Return a css property mapped to a potentially vendor prefixed property
function vendorPropName( name ) {

// Shortcut for names that are not vendor prefixed
	if ( name in emptyStyle ) {
		return name;
	}

// Check for vendor prefixed names
	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
		i = cssPrefixes.length;

while ( i-- ) {
		name = cssPrefixes[ i ] + capName;
		if ( name in emptyStyle ) {
			return name;
		}
	}
}

function setPositiveNumber( elem, value, subtract ) {

// Any relative (+/-) values have already been
	// normalized at this point
	var matches = rcssNum.exec( value );
	return matches ?

// Guard against undefined "subtract", e.g., when used as in cssHooks
		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
		value;
}

function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
	var i = extra === ( isBorderBox ? "border" : "content" ) ?

// If we already have the right measurement, avoid augmentation
		4 :

// Otherwise initialize for horizontal or vertical properties
		name === "width" ? 1 : 0,

val = 0;

for ( ; i < 4; i += 2 ) {

// Both box models exclude margin, so add it if we want it
		if ( extra === "margin" ) {
			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
		}

if ( isBorderBox ) {

// border-box includes padding, so remove it if we want content
			if ( extra === "content" ) {
				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
			}

// At this point, extra isn't border nor margin, so remove border
			if ( extra !== "margin" ) {
				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
			}
		} else {

// At this point, extra isn't content, so add padding
			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );

// At this point, extra isn't content nor padding, so add border
			if ( extra !== "padding" ) {
				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
			}
		}
	}

return val;
}

function getWidthOrHeight( elem, name, extra ) {

// Start with offset property, which is equivalent to the border-box value
	var val,
		valueIsBorderBox = true,
		styles = getStyles( elem ),
		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";

// Support: IE <=11 only
	// Running getBoundingClientRect on a disconnected node
	// in IE throws an error.
	if ( elem.getClientRects().length ) {
		val = elem.getBoundingClientRect()[ name ];
	}

// Some non-html elements return undefined for offsetWidth, so check for null/undefined
	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
	if ( val <= 0 || val == null ) {

// Fall back to computed then uncomputed css if necessary
		val = curCSS( elem, name, styles );
		if ( val < 0 || val == null ) {
			val = elem.style[ name ];
		}

// Computed unit is not pixels. Stop here and return.
		if ( rnumnonpx.test( val ) ) {
			return val;
		}

// Check for style in case a browser which returns unreliable values
		// for getComputedStyle silently falls back to the reliable elem.style
		valueIsBorderBox = isBorderBox &&
			( support.boxSizingReliable() || val === elem.style[ name ] );

// Normalize "", auto, and prepare for extra
		val = parseFloat( val ) || 0;
	}

// Use the active box-sizing model to add/subtract irrelevant styles
	return ( val +
		augmentWidthOrHeight(
			elem,
			name,
			extra || ( isBorderBox ? "border" : "content" ),
			valueIsBorderBox,
			styles
		)
	) + "px";
}

jQuery.extend( {

// Add in style property hooks for overriding the default
	// behavior of getting and setting a style property
	cssHooks: {
		opacity: {
			get: function( elem, computed ) {
				if ( computed ) {

// We should always get a number back from opacity
					var ret = curCSS( elem, "opacity" );
					return ret === "" ? "1" : ret;
				}
			}
		}
	},

// Don't automatically add "px" to these possibly-unitless properties
	cssNumber: {
		"animationIterationCount": true,
		"columnCount": true,
		"fillOpacity": true,
		"flexGrow": true,
		"flexShrink": true,
		"fontWeight": true,
		"lineHeight": true,
		"opacity": true,
		"order": true,
		"orphans": true,
		"widows": true,
		"zIndex": true,
		"zoom": true
	},

// Add in properties whose names you wish to fix before
	// setting or getting the value
	cssProps: {
		"float": "cssFloat"
	},

// Get and set the style property on a DOM Node
	style: function( elem, name, value, extra ) {

// Don't set styles on text and comment nodes
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
			return;
		}

// Make sure that we're working with the right name
		var ret, type, hooks,
			origName = jQuery.camelCase( name ),
			style = elem.style;

name = jQuery.cssProps[ origName ] ||
			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );

// Gets hook for the prefixed version, then unprefixed version
		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

// Check if we're setting a value
		if ( value !== undefined ) {
			type = typeof value;

// Convert "+=" or "-=" to relative numbers (#7345)
			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
				value = adjustCSS( elem, name, ret );

// Fixes bug #9237
				type = "number";
			}

// Make sure that null and NaN values aren't set (#7116)
			if ( value == null || value !== value ) {
				return;
			}

// If a number was passed in, add the unit (except for certain CSS properties)
			if ( type === "number" ) {
				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
			}

// background-* props affect original clone's values
			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
				style[ name ] = "inherit";
			}

// If a hook was provided, use that value, otherwise just set the specified value
			if ( !hooks || !( "set" in hooks ) ||
				( value = hooks.set( elem, value, extra ) ) !== undefined ) {

style[ name ] = value;
			}

} else {

// If a hook was provided get the non-computed value from there
			if ( hooks && "get" in hooks &&
				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {

return ret;
			}

// Otherwise just get the value from the style object
			return style[ name ];
		}
	},

css: function( elem, name, extra, styles ) {
		var val, num, hooks,
			origName = jQuery.camelCase( name );

// Make sure that we're working with the right name
		name = jQuery.cssProps[ origName ] ||
			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );

// Try prefixed name followed by the unprefixed name
		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

// If a hook was provided get the computed value from there
		if ( hooks && "get" in hooks ) {
			val = hooks.get( elem, true, extra );
		}

// Otherwise, if a way to get the computed value exists, use that
		if ( val === undefined ) {
			val = curCSS( elem, name, styles );
		}

// Convert "normal" to computed value
		if ( val === "normal" && name in cssNormalTransform ) {
			val = cssNormalTransform[ name ];
		}

// Make numeric if forced or a qualifier was provided and val looks numeric
		if ( extra === "" || extra ) {
			num = parseFloat( val );
			return extra === true || isFinite( num ) ? num || 0 : val;
		}
		return val;
	}
} );

jQuery.each( [ "height", "width" ], function( i, name ) {
	jQuery.cssHooks[ name ] = {
		get: function( elem, computed, extra ) {
			if ( computed ) {

// Certain elements can have dimension info if we invisibly show them
				// but it must have a current display style that would benefit
				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&

// Support: Safari 8+
					// Table columns in Safari have non-zero offsetWidth & zero
					// getBoundingClientRect().width unless display is changed.
					// Support: IE <=11 only
					// Running getBoundingClientRect on a disconnected node
					// in IE throws an error.
					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
						swap( elem, cssShow, function() {
							return getWidthOrHeight( elem, name, extra );
						} ) :
						getWidthOrHeight( elem, name, extra );
			}
		},

set: function( elem, value, extra ) {
			var matches,
				styles = extra && getStyles( elem ),
				subtract = extra && augmentWidthOrHeight(
					elem,
					name,
					extra,
					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
					styles
				);

// Convert to pixels if value adjustment is needed
			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
				( matches[ 3 ] || "px" ) !== "px" ) {

elem.style[ name ] = value;
				value = jQuery.css( elem, name );
			}

return setPositiveNumber( elem, value, subtract );
		}
	};
} );

jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
	function( elem, computed ) {
		if ( computed ) {
			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
				elem.getBoundingClientRect().left -
					swap( elem, { marginLeft: 0 }, function() {
						return elem.getBoundingClientRect().left;
					} )
				) + "px";
		}
	}
);

// These hooks are used by animate to expand properties
jQuery.each( {
	margin: "",
	padding: "",
	border: "Width"
}, function( prefix, suffix ) {
	jQuery.cssHooks[ prefix + suffix ] = {
		expand: function( value ) {
			var i = 0,
				expanded = {},

// Assumes a single number if not a string
				parts = typeof value === "string" ? value.split( " " ) : [ value ];

for ( ; i < 4; i++ ) {
				expanded[ prefix + cssExpand[ i ] + suffix ] =
					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
			}

return expanded;
		}
	};

if ( !rmargin.test( prefix ) ) {
		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
	}
} );

jQuery.fn.extend( {
	css: function( name, value ) {
		return access( this, function( elem, name, value ) {
			var styles, len,
				map = {},
				i = 0;

if ( jQuery.isArray( name ) ) {
				styles = getStyles( elem );
				len = name.length;

for ( ; i < len; i++ ) {
					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
				}

return map;
			}

return value !== undefined ?
				jQuery.style( elem, name, value ) :
				jQuery.css( elem, name );
		}, name, value, arguments.length > 1 );
	}
} );

function Tween( elem, options, prop, end, easing ) {
	return new Tween.prototype.init( elem, options, prop, end, easing );
}
jQuery.Tween = Tween;

Tween.prototype = {
	constructor: Tween,
	init: function( elem, options, prop, end, easing, unit ) {
		this.elem = elem;
		this.prop = prop;
		this.easing = easing || jQuery.easing._default;
		this.options = options;
		this.start = this.now = this.cur();
		this.end = end;
		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
	},
	cur: function() {
		var hooks = Tween.propHooks[ this.prop ];

return hooks && hooks.get ?
			hooks.get( this ) :
			Tween.propHooks._default.get( this );
	},
	run: function( percent ) {
		var eased,
			hooks = Tween.propHooks[ this.prop ];

if ( this.options.duration ) {
			this.pos = eased = jQuery.easing[ this.easing ](
				percent, this.options.duration * percent, 0, 1, this.options.duration
			);
		} else {
			this.pos = eased = percent;
		}
		this.now = ( this.end - this.start ) * eased + this.start;

if ( this.options.step ) {
			this.options.step.call( this.elem, this.now, this );
		}

if ( hooks && hooks.set ) {
			hooks.set( this );
		} else {
			Tween.propHooks._default.set( this );
		}
		return this;
	}
};

Tween.prototype.init.prototype = Tween.prototype;

Tween.propHooks = {
	_default: {
		get: function( tween ) {
			var result;

// Use a property on the element directly when it is not a DOM element,
			// or when there is no matching style property that exists.
			if ( tween.elem.nodeType !== 1 ||
				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
				return tween.elem[ tween.prop ];
			}

// Passing an empty string as a 3rd parameter to .css will automatically
			// attempt a parseFloat and fallback to a string if the parse fails.
			// Simple values such as "10px" are parsed to Float;
			// complex values such as "rotate(1rad)" are returned as-is.
			result = jQuery.css( tween.elem, tween.prop, "" );

// Empty strings, null, undefined and "auto" are converted to 0.
			return !result || result === "auto" ? 0 : result;
		},
		set: function( tween ) {

// Use step hook for back compat.
			// Use cssHook if its there.
			// Use .style if available and use plain properties where available.
			if ( jQuery.fx.step[ tween.prop ] ) {
				jQuery.fx.step[ tween.prop ]( tween );
			} else if ( tween.elem.nodeType === 1 &&
				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
					jQuery.cssHooks[ tween.prop ] ) ) {
				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
			} else {
				tween.elem[ tween.prop ] = tween.now;
			}
		}
	}
};

// Support: IE <=9 only
// Panic based approach to setting things on disconnected nodes
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
	set: function( tween ) {
		if ( tween.elem.nodeType && tween.elem.parentNode ) {
			tween.elem[ tween.prop ] = tween.now;
		}
	}
};

jQuery.easing = {
	linear: function( p ) {
		return p;
	},
	swing: function( p ) {
		return 0.5 - Math.cos( p * Math.PI ) / 2;
	},
	_default: "swing"
};

jQuery.fx = Tween.prototype.init;

// Back compat <1.8 extension point
jQuery.fx.step = {};

var
	fxNow, timerId,
	rfxtypes = /^(?:toggle|show|hide)$/,
	rrun = /queueHooks$/;

function raf() {
	if ( timerId ) {
		window.requestAnimationFrame( raf );
		jQuery.fx.tick();
	}
}

// Animations created synchronously will run synchronously
function createFxNow() {
	window.setTimeout( function() {
		fxNow = undefined;
	} );
	return ( fxNow = jQuery.now() );
}

// Generate parameters to create a standard animation
function genFx( type, includeWidth ) {
	var which,
		i = 0,
		attrs = { height: type };

// If we include width, step value is 1 to do all cssExpand values,
	// otherwise step value is 2 to skip over Left and Right
	includeWidth = includeWidth ? 1 : 0;
	for ( ; i < 4; i += 2 - includeWidth ) {
		which = cssExpand[ i ];
		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
	}

if ( includeWidth ) {
		attrs.opacity = attrs.width = type;
	}

return attrs;
}

function createTween( value, prop, animation ) {
	var tween,
		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
		index = 0,
		length = collection.length;
	for ( ; index < length; index++ ) {
		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {

// We're done with this property
			return tween;
		}
	}
}

function defaultPrefilter( elem, props, opts ) {
	var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
		isBox = "width" in props || "height" in props,
		anim = this,
		orig = {},
		style = elem.style,
		hidden = elem.nodeType && isHiddenWithinTree( elem ),
		dataShow = dataPriv.get( elem, "fxshow" );

// Queue-skipping animations hijack the fx hooks
	if ( !opts.queue ) {
		hooks = jQuery._queueHooks( elem, "fx" );
		if ( hooks.unqueued == null ) {
			hooks.unqueued = 0;
			oldfire = hooks.empty.fire;
			hooks.empty.fire = function() {
				if ( !hooks.unqueued ) {
					oldfire();
				}
			};
		}
		hooks.unqueued++;

anim.always( function() {

// Ensure the complete handler is called before this completes
			anim.always( function() {
				hooks.unqueued--;
				if ( !jQuery.queue( elem, "fx" ).length ) {
					hooks.empty.fire();
				}
			} );
		} );
	}

// Detect show/hide animations
	for ( prop in props ) {
		value = props[ prop ];
		if ( rfxtypes.test( value ) ) {
			delete props[ prop ];
			toggle = toggle || value === "toggle";
			if ( value === ( hidden ? "hide" : "show" ) ) {

// Pretend to be hidden if this is a "show" and
				// there is still data from a stopped show/hide
				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
					hidden = true;

// Ignore all other no-op show/hide data
				} else {
					continue;
				}
			}
			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
		}
	}

// Bail out if this is a no-op like .hide().hide()
	propTween = !jQuery.isEmptyObject( props );
	if ( !propTween && jQuery.isEmptyObject( orig ) ) {
		return;
	}

// Restrict "overflow" and "display" styles during box animations
	if ( isBox && elem.nodeType === 1 ) {

// Support: IE <=9 - 11, Edge 12 - 13
		// Record all 3 overflow attributes because IE does not infer the shorthand
		// from identically-valued overflowX and overflowY
		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];

// Identify a display type, preferring old show/hide data over the CSS cascade
		restoreDisplay = dataShow && dataShow.display;
		if ( restoreDisplay == null ) {
			restoreDisplay = dataPriv.get( elem, "display" );
		}
		display = jQuery.css( elem, "display" );
		if ( display === "none" ) {
			if ( restoreDisplay ) {
				display = restoreDisplay;
			} else {

// Get nonempty value(s) by temporarily forcing visibility
				showHide( [ elem ], true );
				restoreDisplay = elem.style.display || restoreDisplay;
				display = jQuery.css( elem, "display" );
				showHide( [ elem ] );
			}
		}

// Animate inline elements as inline-block
		if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
			if ( jQuery.css( elem, "float" ) === "none" ) {

// Restore the original display value at the end of pure show/hide animations
				if ( !propTween ) {
					anim.done( function() {
						style.display = restoreDisplay;
					} );
					if ( restoreDisplay == null ) {
						display = style.display;
						restoreDisplay = display === "none" ? "" : display;
					}
				}
				style.display = "inline-block";
			}
		}
	}

if ( opts.overflow ) {
		style.overflow = "hidden";
		anim.always( function() {
			style.overflow = opts.overflow[ 0 ];
			style.overflowX = opts.overflow[ 1 ];
			style.overflowY = opts.overflow[ 2 ];
		} );
	}

// Implement show/hide animations
	propTween = false;
	for ( prop in orig ) {

// General show/hide setup for this element animation
		if ( !propTween ) {
			if ( dataShow ) {
				if ( "hidden" in dataShow ) {
					hidden = dataShow.hidden;
				}
			} else {
				dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
			}

// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
			if ( toggle ) {
				dataShow.hidden = !hidden;
			}

// Show elements before animating them
			if ( hidden ) {
				showHide( [ elem ], true );
			}

/* eslint-disable no-loop-func */

anim.done( function() {

/* eslint-enable no-loop-func */

// The final step of a "hide" animation is actually hiding the element
				if ( !hidden ) {
					showHide( [ elem ] );
				}
				dataPriv.remove( elem, "fxshow" );
				for ( prop in orig ) {
					jQuery.style( elem, prop, orig[ prop ] );
				}
			} );
		}

// Per-property setup
		propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
		if ( !( prop in dataShow ) ) {
			dataShow[ prop ] = propTween.start;
			if ( hidden ) {
				propTween.end = propTween.start;
				propTween.start = 0;
			}
		}
	}
}

function propFilter( props, specialEasing ) {
	var index, name, easing, value, hooks;

// camelCase, specialEasing and expand cssHook pass
	for ( index in props ) {
		name = jQuery.camelCase( index );
		easing = specialEasing[ name ];
		value = props[ index ];
		if ( jQuery.isArray( value ) ) {
			easing = value[ 1 ];
			value = props[ index ] = value[ 0 ];
		}

if ( index !== name ) {
			props[ name ] = value;
			delete props[ index ];
		}

hooks = jQuery.cssHooks[ name ];
		if ( hooks && "expand" in hooks ) {
			value = hooks.expand( value );
			delete props[ name ];

// Not quite $.extend, this won't overwrite existing keys.
			// Reusing 'index' because we have the correct "name"
			for ( index in value ) {
				if ( !( index in props ) ) {
					props[ index ] = value[ index ];
					specialEasing[ index ] = easing;
				}
			}
		} else {
			specialEasing[ name ] = easing;
		}
	}
}

function Animation( elem, properties, options ) {
	var result,
		stopped,
		index = 0,
		length = Animation.prefilters.length,
		deferred = jQuery.Deferred().always( function() {

// Don't match elem in the :animated selector
			delete tick.elem;
		} ),
		tick = function() {
			if ( stopped ) {
				return false;
			}
			var currentTime = fxNow || createFxNow(),
				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),

// Support: Android 2.3 only
				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
				temp = remaining / animation.duration || 0,
				percent = 1 - temp,
				index = 0,
				length = animation.tweens.length;

for ( ; index < length; index++ ) {
				animation.tweens[ index ].run( percent );
			}

deferred.notifyWith( elem, [ animation, percent, remaining ] );

if ( percent < 1 && length ) {
				return remaining;
			} else {
				deferred.resolveWith( elem, [ animation ] );
				return false;
			}
		},
		animation = deferred.promise( {
			elem: elem,
			props: jQuery.extend( {}, properties ),
			opts: jQuery.extend( true, {
				specialEasing: {},
				easing: jQuery.easing._default
			}, options ),
			originalProperties: properties,
			originalOptions: options,
			startTime: fxNow || createFxNow(),
			duration: options.duration,
			tweens: [],
			createTween: function( prop, end ) {
				var tween = jQuery.Tween( elem, animation.opts, prop, end,
						animation.opts.specialEasing[ prop ] || animation.opts.easing );
				animation.tweens.push( tween );
				return tween;
			},
			stop: function( gotoEnd ) {
				var index = 0,

// If we are going to the end, we want to run all the tweens
					// otherwise we skip this part
					length = gotoEnd ? animation.tweens.length : 0;
				if ( stopped ) {
					return this;
				}
				stopped = true;
				for ( ; index < length; index++ ) {
					animation.tweens[ index ].run( 1 );
				}

// Resolve when we played the last frame; otherwise, reject
				if ( gotoEnd ) {
					deferred.notifyWith( elem, [ animation, 1, 0 ] );
					deferred.resolveWith( elem, [ animation, gotoEnd ] );
				} else {
					deferred.rejectWith( elem, [ animation, gotoEnd ] );
				}
				return this;
			}
		} ),
		props = animation.props;

propFilter( props, animation.opts.specialEasing );

for ( ; index < length; index++ ) {
		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
		if ( result ) {
			if ( jQuery.isFunction( result.stop ) ) {
				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
					jQuery.proxy( result.stop, result );
			}
			return result;
		}
	}

jQuery.map( props, createTween, animation );

if ( jQuery.isFunction( animation.opts.start ) ) {
		animation.opts.start.call( elem, animation );
	}

jQuery.fx.timer(
		jQuery.extend( tick, {
			elem: elem,
			anim: animation,
			queue: animation.opts.queue
		} )
	);

// attach callbacks from options
	return animation.progress( animation.opts.progress )
		.done( animation.opts.done, animation.opts.complete )
		.fail( animation.opts.fail )
		.always( animation.opts.always );
}

jQuery.Animation = jQuery.extend( Animation, {

tweeners: {
		"*": [ function( prop, value ) {
			var tween = this.createTween( prop, value );
			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
			return tween;
		} ]
	},

tweener: function( props, callback ) {
		if ( jQuery.isFunction( props ) ) {
			callback = props;
			props = [ "*" ];
		} else {
			props = props.match( rnotwhite );
		}

var prop,
			index = 0,
			length = props.length;

for ( ; index < length; index++ ) {
			prop = props[ index ];
			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
			Animation.tweeners[ prop ].unshift( callback );
		}
	},

prefilters: [ defaultPrefilter ],

prefilter: function( callback, prepend ) {
		if ( prepend ) {
			Animation.prefilters.unshift( callback );
		} else {
			Animation.prefilters.push( callback );
		}
	}
} );

jQuery.speed = function( speed, easing, fn ) {
	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
		complete: fn || !fn && easing ||
			jQuery.isFunction( speed ) && speed,
		duration: speed,
		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
	};

// Go to the end state if fx are off or if document is hidden
	if ( jQuery.fx.off || document.hidden ) {
		opt.duration = 0;

} else {
		opt.duration = typeof opt.duration === "number" ?
			opt.duration : opt.duration in jQuery.fx.speeds ?
				jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
	}

// Normalize opt.queue - true/undefined/null -> "fx"
	if ( opt.queue == null || opt.queue === true ) {
		opt.queue = "fx";
	}

// Queueing
	opt.old = opt.complete;

opt.complete = function() {
		if ( jQuery.isFunction( opt.old ) ) {
			opt.old.call( this );
		}

if ( opt.queue ) {
			jQuery.dequeue( this, opt.queue );
		}
	};

return opt;
};

jQuery.fn.extend( {
	fadeTo: function( speed, to, easing, callback ) {

// Show any hidden elements after setting opacity to 0
		return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()

// Animate to the value specified
			.end().animate( { opacity: to }, speed, easing, callback );
	},
	animate: function( prop, speed, easing, callback ) {
		var empty = jQuery.isEmptyObject( prop ),
			optall = jQuery.speed( speed, easing, callback ),
			doAnimation = function() {

// Operate on a copy of prop so per-property easing won't be lost
				var anim = Animation( this, jQuery.extend( {}, prop ), optall );

// Empty animations, or finishing resolves immediately
				if ( empty || dataPriv.get( this, "finish" ) ) {
					anim.stop( true );
				}
			};
			doAnimation.finish = doAnimation;

return empty || optall.queue === false ?
			this.each( doAnimation ) :
			this.queue( optall.queue, doAnimation );
	},
	stop: function( type, clearQueue, gotoEnd ) {
		var stopQueue = function( hooks ) {
			var stop = hooks.stop;
			delete hooks.stop;
			stop( gotoEnd );
		};

if ( typeof type !== "string" ) {
			gotoEnd = clearQueue;
			clearQueue = type;
			type = undefined;
		}
		if ( clearQueue && type !== false ) {
			this.queue( type || "fx", [] );
		}

return this.each( function() {
			var dequeue = true,
				index = type != null && type + "queueHooks",
				timers = jQuery.timers,
				data = dataPriv.get( this );

if ( index ) {
				if ( data[ index ] && data[ index ].stop ) {
					stopQueue( data[ index ] );
				}
			} else {
				for ( index in data ) {
					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
						stopQueue( data[ index ] );
					}
				}
			}

for ( index = timers.length; index--; ) {
				if ( timers[ index ].elem === this &&
					( type == null || timers[ index ].queue === type ) ) {

timers[ index ].anim.stop( gotoEnd );
					dequeue = false;
					timers.splice( index, 1 );
				}
			}

// Start the next in the queue if the last step wasn't forced.
			// Timers currently will call their complete callbacks, which
			// will dequeue but only if they were gotoEnd.
			if ( dequeue || !gotoEnd ) {
				jQuery.dequeue( this, type );
			}
		} );
	},
	finish: function( type ) {
		if ( type !== false ) {
			type = type || "fx";
		}
		return this.each( function() {
			var index,
				data = dataPriv.get( this ),
				queue = data[ type + "queue" ],
				hooks = data[ type + "queueHooks" ],
				timers = jQuery.timers,
				length = queue ? queue.length : 0;

// Enable finishing flag on private data
			data.finish = true;

// Empty the queue first
			jQuery.queue( this, type, [] );

if ( hooks && hooks.stop ) {
				hooks.stop.call( this, true );
			}

// Look for any active animations, and finish them
			for ( index = timers.length; index--; ) {
				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
					timers[ index ].anim.stop( true );
					timers.splice( index, 1 );
				}
			}

// Look for any animations in the old queue and finish them
			for ( index = 0; index < length; index++ ) {
				if ( queue[ index ] && queue[ index ].finish ) {
					queue[ index ].finish.call( this );
				}
			}

// Turn off finishing flag
			delete data.finish;
		} );
	}
} );

jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
	var cssFn = jQuery.fn[ name ];
	jQuery.fn[ name ] = function( speed, easing, callback ) {
		return speed == null || typeof speed === "boolean" ?
			cssFn.apply( this, arguments ) :
			this.animate( genFx( name, true ), speed, easing, callback );
	};
} );

// Generate shortcuts for custom animations
jQuery.each( {
	slideDown: genFx( "show" ),
	slideUp: genFx( "hide" ),
	slideToggle: genFx( "toggle" ),
	fadeIn: { opacity: "show" },
	fadeOut: { opacity: "hide" },
	fadeToggle: { opacity: "toggle" }
}, function( name, props ) {
	jQuery.fn[ name ] = function( speed, easing, callback ) {
		return this.animate( props, speed, easing, callback );
	};
} );

jQuery.timers = [];
jQuery.fx.tick = function() {
	var timer,
		i = 0,
		timers = jQuery.timers;

fxNow = jQuery.now();

for ( ; i < timers.length; i++ ) {
		timer = timers[ i ];

// Checks the timer has not already been removed
		if ( !timer() && timers[ i ] === timer ) {
			timers.splice( i--, 1 );
		}
	}

if ( !timers.length ) {
		jQuery.fx.stop();
	}
	fxNow = undefined;
};

jQuery.fx.timer = function( timer ) {
	jQuery.timers.push( timer );
	if ( timer() ) {
		jQuery.fx.start();
	} else {
		jQuery.timers.pop();
	}
};

jQuery.fx.interval = 13;
jQuery.fx.start = function() {
	if ( !timerId ) {
		timerId = window.requestAnimationFrame ?
			window.requestAnimationFrame( raf ) :
			window.setInterval( jQuery.fx.tick, jQuery.fx.interval );
	}
};

jQuery.fx.stop = function() {
	if ( window.cancelAnimationFrame ) {
		window.cancelAnimationFrame( timerId );
	} else {
		window.clearInterval( timerId );
	}

timerId = null;
};

jQuery.fx.speeds = {
	slow: 600,
	fast: 200,

// Default speed
	_default: 400
};

// Based off of the plugin by Clint Helfers, with permission.
// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
jQuery.fn.delay = function( time, type ) {
	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
	type = type || "fx";

return this.queue( type, function( next, hooks ) {
		var timeout = window.setTimeout( next, time );
		hooks.stop = function() {
			window.clearTimeout( timeout );
		};
	} );
};

( function() {
	var input = document.createElement( "input" ),
		select = document.createElement( "select" ),
		opt = select.appendChild( document.createElement( "option" ) );

input.type = "checkbox";

// Support: Android <=4.3 only
	// Default value for a checkbox should be "on"
	support.checkOn = input.value !== "";

// Support: IE <=11 only
	// Must access selectedIndex to make default options select
	support.optSelected = opt.selected;

// Support: IE <=11 only
	// An input loses its value after becoming a radio
	input = document.createElement( "input" );
	input.value = "t";
	input.type = "radio";
	support.radioValue = input.value === "t";
} )();

var boolHook,
	attrHandle = jQuery.expr.attrHandle;

jQuery.fn.extend( {
	attr: function( name, value ) {
		return access( this, jQuery.attr, name, value, arguments.length > 1 );
	},

removeAttr: function( name ) {
		return this.each( function() {
			jQuery.removeAttr( this, name );
		} );
	}
} );

jQuery.extend( {
	attr: function( elem, name, value ) {
		var ret, hooks,
			nType = elem.nodeType;

// Don't get/set attributes on text, comment and attribute nodes
		if ( nType === 3 || nType === 8 || nType === 2 ) {
			return;
		}

// Fallback to prop when attributes are not supported
		if ( typeof elem.getAttribute === "undefined" ) {
			return jQuery.prop( elem, name, value );
		}

// Attribute hooks are determined by the lowercase version
		// Grab necessary hook if one is defined
		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
		}

if ( value !== undefined ) {
			if ( value === null ) {
				jQuery.removeAttr( elem, name );
				return;
			}

if ( hooks && "set" in hooks &&
				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
				return ret;
			}

elem.setAttribute( name, value + "" );
			return value;
		}

if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
			return ret;
		}

ret = jQuery.find.attr( elem, name );

// Non-existent attributes return null, we normalize to undefined
		return ret == null ? undefined : ret;
	},

attrHooks: {
		type: {
			set: function( elem, value ) {
				if ( !support.radioValue && value === "radio" &&
					jQuery.nodeName( elem, "input" ) ) {
					var val = elem.value;
					elem.setAttribute( "type", value );
					if ( val ) {
						elem.value = val;
					}
					return value;
				}
			}
		}
	},

removeAttr: function( elem, value ) {
		var name,
			i = 0,
			attrNames = value && value.match( rnotwhite );

if ( attrNames && elem.nodeType === 1 ) {
			while ( ( name = attrNames[ i++ ] ) ) {
				elem.removeAttribute( name );
			}
		}
	}
} );

// Hooks for boolean attributes
boolHook = {
	set: function( elem, value, name ) {
		if ( value === false ) {

// Remove boolean attributes when set to false
			jQuery.removeAttr( elem, name );
		} else {
			elem.setAttribute( name, name );
		}
		return name;
	}
};

jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
	var getter = attrHandle[ name ] || jQuery.find.attr;

attrHandle[ name ] = function( elem, name, isXML ) {
		var ret, handle,
			lowercaseName = name.toLowerCase();

if ( !isXML ) {

// Avoid an infinite loop by temporarily removing this function from the getter
			handle = attrHandle[ lowercaseName ];
			attrHandle[ lowercaseName ] = ret;
			ret = getter( elem, name, isXML ) != null ?
				lowercaseName :
				null;
			attrHandle[ lowercaseName ] = handle;
		}
		return ret;
	};
} );

var rfocusable = /^(?:input|select|textarea|button)$/i,
	rclickable = /^(?:a|area)$/i;

jQuery.fn.extend( {
	prop: function( name, value ) {
		return access( this, jQuery.prop, name, value, arguments.length > 1 );
	},

removeProp: function( name ) {
		return this.each( function() {
			delete this[ jQuery.propFix[ name ] || name ];
		} );
	}
} );

jQuery.extend( {
	prop: function( elem, name, value ) {
		var ret, hooks,
			nType = elem.nodeType;

// Don't get/set properties on text, comment and attribute nodes
		if ( nType === 3 || nType === 8 || nType === 2 ) {
			return;
		}

if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {

// Fix name and attach hooks
			name = jQuery.propFix[ name ] || name;
			hooks = jQuery.propHooks[ name ];
		}

if ( value !== undefined ) {
			if ( hooks && "set" in hooks &&
				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
				return ret;
			}

return ( elem[ name ] = value );
		}

if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
			return ret;
		}

return elem[ name ];
	},

propHooks: {
		tabIndex: {
			get: function( elem ) {

// Support: IE <=9 - 11 only
				// elem.tabIndex doesn't always return the
				// correct value when it hasn't been explicitly set
				// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
				// Use proper attribute retrieval(#12072)
				var tabindex = jQuery.find.attr( elem, "tabindex" );

return tabindex ?
					parseInt( tabindex, 10 ) :
					rfocusable.test( elem.nodeName ) ||
						rclickable.test( elem.nodeName ) && elem.href ?
							0 :
							-1;
			}
		}
	},

propFix: {
		"for": "htmlFor",
		"class": "className"
	}
} );

// Support: IE <=11 only
// Accessing the selectedIndex property
// forces the browser to respect setting selected
// on the option
// The getter ensures a default option is selected
// when in an optgroup
if ( !support.optSelected ) {
	jQuery.propHooks.selected = {
		get: function( elem ) {
			var parent = elem.parentNode;
			if ( parent && parent.parentNode ) {
				parent.parentNode.selectedIndex;
			}
			return null;
		},
		set: function( elem ) {
			var parent = elem.parentNode;
			if ( parent ) {
				parent.selectedIndex;

if ( parent.parentNode ) {
					parent.parentNode.selectedIndex;
				}
			}
		}
	};
}

jQuery.each( [
	"tabIndex",
	"readOnly",
	"maxLength",
	"cellSpacing",
	"cellPadding",
	"rowSpan",
	"colSpan",
	"useMap",
	"frameBorder",
	"contentEditable"
], function() {
	jQuery.propFix[ this.toLowerCase() ] = this;
} );

var rclass = /[\t\r\n\f]/g;

function getClass( elem ) {
	return elem.getAttribute && elem.getAttribute( "class" ) || "";
}

jQuery.fn.extend( {
	addClass: function( value ) {
		var classes, elem, cur, curValue, clazz, j, finalValue,
			i = 0;

if ( jQuery.isFunction( value ) ) {
			return this.each( function( j ) {
				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
			} );
		}

if ( typeof value === "string" && value ) {
			classes = value.match( rnotwhite ) || [];

while ( ( elem = this[ i++ ] ) ) {
				curValue = getClass( elem );
				cur = elem.nodeType === 1 &&
					( " " + curValue + " " ).replace( rclass, " " );

if ( cur ) {
					j = 0;
					while ( ( clazz = classes[ j++ ] ) ) {
						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
							cur += clazz + " ";
						}
					}

// Only assign if different to avoid unneeded rendering.
					finalValue = jQuery.trim( cur );
					if ( curValue !== finalValue ) {
						elem.setAttribute( "class", finalValue );
					}
				}
			}
		}

return this;
	},

removeClass: function( value ) {
		var classes, elem, cur, curValue, clazz, j, finalValue,
			i = 0;

if ( jQuery.isFunction( value ) ) {
			return this.each( function( j ) {
				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
			} );
		}

if ( !arguments.length ) {
			return this.attr( "class", "" );
		}

if ( typeof value === "string" && value ) {
			classes = value.match( rnotwhite ) || [];

while ( ( elem = this[ i++ ] ) ) {
				curValue = getClass( elem );

// This expression is here for better compressibility (see addClass)
				cur = elem.nodeType === 1 &&
					( " " + curValue + " " ).replace( rclass, " " );

if ( cur ) {
					j = 0;
					while ( ( clazz = classes[ j++ ] ) ) {

// Remove *all* instances
						while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
							cur = cur.replace( " " + clazz + " ", " " );
						}
					}

return this;
	},

toggleClass: function( value, stateVal ) {
		var type = typeof value;

if ( typeof stateVal === "boolean" && type === "string" ) {
			return stateVal ? this.addClass( value ) : this.removeClass( value );
		}

if ( jQuery.isFunction( value ) ) {
			return this.each( function( i ) {
				jQuery( this ).toggleClass(
					value.call( this, i, getClass( this ), stateVal ),
					stateVal
				);
			} );
		}

return this.each( function() {
			var className, i, self, classNames;

if ( type === "string" ) {

// Toggle individual class names
				i = 0;
				self = jQuery( this );
				classNames = value.match( rnotwhite ) || [];

while ( ( className = classNames[ i++ ] ) ) {

// Check each className given, space separated list
					if ( self.hasClass( className ) ) {
						self.removeClass( className );
					} else {
						self.addClass( className );
					}
				}

// Toggle whole class name
			} else if ( value === undefined || type === "boolean" ) {
				className = getClass( this );
				if ( className ) {

// Store className if set
					dataPriv.set( this, "__className__", className );
				}

// If the element has a class name or if we're passed `false`,
				// then remove the whole classname (if there was one, the above saved it).
				// Otherwise bring back whatever was previously saved (if anything),
				// falling back to the empty string if nothing was stored.
				if ( this.setAttribute ) {
					this.setAttribute( "class",
						className || value === false ?
						"" :
						dataPriv.get( this, "__className__" ) || ""
					);
				}
			}
		} );
	},

hasClass: function( selector ) {
		var className, elem,
			i = 0;

className = " " + selector + " ";
		while ( ( elem = this[ i++ ] ) ) {
			if ( elem.nodeType === 1 &&
				( " " + getClass( elem ) + " " ).replace( rclass, " " )
					.indexOf( className ) > -1
			) {
				return true;
			}
		}

return false;
	}
} );

var rreturn = /\r/g,
	rspaces = /[\x20\t\r\n\f]+/g;

jQuery.fn.extend( {
	val: function( value ) {
		var hooks, ret, isFunction,
			elem = this[ 0 ];

if ( !arguments.length ) {
			if ( elem ) {
				hooks = jQuery.valHooks[ elem.type ] ||
					jQuery.valHooks[ elem.nodeName.toLowerCase() ];

if ( hooks &&
					"get" in hooks &&
					( ret = hooks.get( elem, "value" ) ) !== undefined
				) {
					return ret;
				}

ret = elem.value;

return typeof ret === "string" ?

// Handle most common string cases
					ret.replace( rreturn, "" ) :

// Handle cases where value is null/undef or number
					ret == null ? "" : ret;
			}

return;
		}

isFunction = jQuery.isFunction( value );

return this.each( function( i ) {
			var val;

if ( this.nodeType !== 1 ) {
				return;
			}

if ( isFunction ) {
				val = value.call( this, i, jQuery( this ).val() );
			} else {
				val = value;
			}

// Treat null/undefined as ""; convert numbers to string
			if ( val == null ) {
				val = "";

} else if ( typeof val === "number" ) {
				val += "";

} else if ( jQuery.isArray( val ) ) {
				val = jQuery.map( val, function( value ) {
					return value == null ? "" : value + "";
				} );
			}

hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];

// If set returns undefined, fall back to normal setting
			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
				this.value = val;
			}
		} );
	}
} );

jQuery.extend( {
	valHooks: {
		option: {
			get: function( elem ) {

var val = jQuery.find.attr( elem, "value" );
				return val != null ?
					val :

// Support: IE <=10 - 11 only
					// option.text throws exceptions (#14686, #14858)
					// Strip and collapse whitespace
					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
					jQuery.trim( jQuery.text( elem ) ).replace( rspaces, " " );
			}
		},
		select: {
			get: function( elem ) {
				var value, option,
					options = elem.options,
					index = elem.selectedIndex,
					one = elem.type === "select-one",
					values = one ? null : [],
					max = one ? index + 1 : options.length,
					i = index < 0 ?
						max :
						one ? index : 0;

// Loop through all the selected options
				for ( ; i < max; i++ ) {
					option = options[ i ];

// Support: IE <=9 only
					// IE8-9 doesn't update selected after form reset (#2551)
					if ( ( option.selected || i === index ) &&

// Don't return options that are disabled or in a disabled optgroup
							!option.disabled &&
							( !option.parentNode.disabled ||
								!jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {

// Get the specific value for the option
						value = jQuery( option ).val();

// We don't need an array for one selects
						if ( one ) {
							return value;
						}

// Multi-Selects return an array
						values.push( value );
					}
				}

return values;
			},

set: function( elem, value ) {
				var optionSet, option,
					options = elem.options,
					values = jQuery.makeArray( value ),
					i = options.length;

while ( i-- ) {
					option = options[ i ];

/* eslint-disable no-cond-assign */

if ( option.selected =
						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
					) {
						optionSet = true;
					}

/* eslint-enable no-cond-assign */
				}

// Force browsers to behave consistently when non-matching value is set
				if ( !optionSet ) {
					elem.selectedIndex = -1;
				}
				return values;
			}
		}
	}
} );

// Radios and checkboxes getter/setter
jQuery.each( [ "radio", "checkbox" ], function() {
	jQuery.valHooks[ this ] = {
		set: function( elem, value ) {
			if ( jQuery.isArray( value ) ) {
				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
			}
		}
	};
	if ( !support.checkOn ) {
		jQuery.valHooks[ this ].get = function( elem ) {
			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
		};
	}
} );

// Return jQuery for attributes-only inclusion

var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;

jQuery.extend( jQuery.event, {

trigger: function( event, data, elem, onlyHandlers ) {

var i, cur, tmp, bubbleType, ontype, handle, special,
			eventPath = [ elem || document ],
			type = hasOwn.call( event, "type" ) ? event.type : event,
			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];

cur = tmp = elem = elem || document;

// Don't do events on text and comment nodes
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
			return;
		}

// focus/blur morphs to focusin/out; ensure we're not firing them right now
		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
			return;
		}

if ( type.indexOf( "." ) > -1 ) {

// Namespaced trigger; create a regexp to match event type in handle()
			namespaces = type.split( "." );
			type = namespaces.shift();
			namespaces.sort();
		}
		ontype = type.indexOf( ":" ) < 0 && "on" + type;

// Caller can pass in a jQuery.Event object, Object, or just an event type string
		event = event[ jQuery.expando ] ?
			event :
			new jQuery.Event( type, typeof event === "object" && event );

// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
		event.isTrigger = onlyHandlers ? 2 : 3;
		event.namespace = namespaces.join( "." );
		event.rnamespace = event.namespace ?
			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
			null;

// Clean up the event in case it is being reused
		event.result = undefined;
		if ( !event.target ) {
			event.target = elem;
		}

// Clone any incoming data and prepend the event, creating the handler arg list
		data = data == null ?
			[ event ] :
			jQuery.makeArray( data, [ event ] );

// Allow special events to draw outside the lines
		special = jQuery.event.special[ type ] || {};
		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
			return;
		}

// Determine event propagation path in advance, per W3C events spec (#9951)
		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {

bubbleType = special.delegateType || type;
			if ( !rfocusMorph.test( bubbleType + type ) ) {
				cur = cur.parentNode;
			}
			for ( ; cur; cur = cur.parentNode ) {
				eventPath.push( cur );
				tmp = cur;
			}

// Only add window if we got to document (e.g., not plain obj or detached DOM)
			if ( tmp === ( elem.ownerDocument || document ) ) {
				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
			}
		}

// Fire handlers on the event path
		i = 0;
		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {

event.type = i > 1 ?
				bubbleType :
				special.bindType || type;

// jQuery handler
			handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
				dataPriv.get( cur, "handle" );
			if ( handle ) {
				handle.apply( cur, data );
			}

// Native handler
			handle = ontype && cur[ ontype ];
			if ( handle && handle.apply && acceptData( cur ) ) {
				event.result = handle.apply( cur, data );
				if ( event.result === false ) {
					event.preventDefault();
				}
			}
		}
		event.type = type;

// If nobody prevented the default action, do it now
		if ( !onlyHandlers && !event.isDefaultPrevented() ) {

if ( ( !special._default ||
				special._default.apply( eventPath.pop(), data ) === false ) &&
				acceptData( elem ) ) {

// Call a native DOM method on the target with the same name as the event.
				// Don't do default actions on window, that's where global variables be (#6170)
				if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {

// Don't re-trigger an onFOO event when we call its FOO() method
					tmp = elem[ ontype ];

if ( tmp ) {
						elem[ ontype ] = null;
					}

// Prevent re-triggering of the same event, since we already bubbled it above
					jQuery.event.triggered = type;
					elem[ type ]();
					jQuery.event.triggered = undefined;

if ( tmp ) {
						elem[ ontype ] = tmp;
					}
				}
			}
		}

return event.result;
	},

// Piggyback on a donor event to simulate a different one
	// Used only for `focus(in | out)` events
	simulate: function( type, elem, event ) {
		var e = jQuery.extend(
			new jQuery.Event(),
			event,
			{
				type: type,
				isSimulated: true
			}
		);

jQuery.event.trigger( e, null, elem );
	}

} );

jQuery.fn.extend( {

trigger: function( type, data ) {
		return this.each( function() {
			jQuery.event.trigger( type, data, this );
		} );
	},
	triggerHandler: function( type, data ) {
		var elem = this[ 0 ];
		if ( elem ) {
			return jQuery.event.trigger( type, data, elem, true );
		}
	}
} );

jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
	function( i, name ) {

// Handle event binding
	jQuery.fn[ name ] = function( data, fn ) {
		return arguments.length > 0 ?
			this.on( name, null, data, fn ) :
			this.trigger( name );
	};
} );

jQuery.fn.extend( {
	hover: function( fnOver, fnOut ) {
		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
	}
} );

support.focusin = "onfocusin" in window;

// Support: Firefox <=44
// Firefox doesn't have focus(in | out) events
// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
//
// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
// focus(in | out) events fire after focus & blur events,
// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
if ( !support.focusin ) {
	jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {

// Attach a single capturing handler on the document while someone wants focusin/focusout
		var handler = function( event ) {
			jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
		};

jQuery.event.special[ fix ] = {
			setup: function() {
				var doc = this.ownerDocument || this,
					attaches = dataPriv.access( doc, fix );

if ( !attaches ) {
					doc.addEventListener( orig, handler, true );
				}
				dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
			},
			teardown: function() {
				var doc = this.ownerDocument || this,
					attaches = dataPriv.access( doc, fix ) - 1;

if ( !attaches ) {
					doc.removeEventListener( orig, handler, true );
					dataPriv.remove( doc, fix );

} else {
					dataPriv.access( doc, fix, attaches );
				}
			}
		};
	} );
}
var location = window.location;

var nonce = jQuery.now();

var rquery = ( /\?/ );

// Cross-browser xml parsing
jQuery.parseXML = function( data ) {
	var xml;
	if ( !data || typeof data !== "string" ) {
		return null;
	}

// Support: IE 9 - 11 only
	// IE throws on parseFromString with invalid input.
	try {
		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
	} catch ( e ) {
		xml = undefined;
	}

if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
		jQuery.error( "Invalid XML: " + data );
	}
	return xml;
};

function buildParams( prefix, obj, traditional, add ) {
	var name;

if ( jQuery.isArray( obj ) ) {

// Serialize array item.
		jQuery.each( obj, function( i, v ) {
			if ( traditional || rbracket.test( prefix ) ) {

// Treat each array item as a scalar.
				add( prefix, v );

} else {

// Item is non-scalar (array or object), encode its numeric index.
				buildParams(
					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
					v,
					traditional,
					add
				);
			}
		} );

} else if ( !traditional && jQuery.type( obj ) === "object" ) {

// Serialize object item.
		for ( name in obj ) {
			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
		}

} else {

// Serialize scalar item.
		add( prefix, obj );
	}
}

// Serialize an array of form elements or a set of
// key/values into a query string
jQuery.param = function( a, traditional ) {
	var prefix,
		s = [],
		add = function( key, valueOrFunction ) {

// If value is a function, invoke it and use its return value
			var value = jQuery.isFunction( valueOrFunction ) ?
				valueOrFunction() :
				valueOrFunction;

s[ s.length ] = encodeURIComponent( key ) + "=" +
				encodeURIComponent( value == null ? "" : value );
		};

// If an array was passed in, assume that it is an array of form elements.
	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {

// Serialize the form elements
		jQuery.each( a, function() {
			add( this.name, this.value );
		} );

} else {

// If traditional, encode the "old" way (the way 1.3.2 or older
		// did it), otherwise encode params recursively.
		for ( prefix in a ) {
			buildParams( prefix, a[ prefix ], traditional, add );
		}
	}

// Return the resulting serialization
	return s.join( "&" );
};

jQuery.fn.extend( {
	serialize: function() {
		return jQuery.param( this.serializeArray() );
	},
	serializeArray: function() {
		return this.map( function() {

// Can add propHook for "elements" to filter or add form elements
			var elements = jQuery.prop( this, "elements" );
			return elements ? jQuery.makeArray( elements ) : this;
		} )
		.filter( function() {
			var type = this.type;

// Use .is( ":disabled" ) so that fieldset[disabled] works
			return this.name && !jQuery( this ).is( ":disabled" ) &&
				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
				( this.checked || !rcheckableType.test( type ) );
		} )
		.map( function( i, elem ) {
			var val = jQuery( this ).val();

return val == null ?
				null :
				jQuery.isArray( val ) ?
					jQuery.map( val, function( val ) {
						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
					} ) :
					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
		} ).get();
	}
} );

var
	r20 = /%20/g,
	rhash = /#.*$/,
	rts = /([?&])_=[^&]*/,
	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,

/* Prefilters
	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
	 * 2) These are called:
	 *    - BEFORE asking for a transport
	 *    - AFTER param serialization (s.data is a string if s.processData is true)
	 * 3) key is the dataType
	 * 4) the catchall symbol "*" can be used
	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
	 */
	prefilters = {},

/* Transports bindings
	 * 1) key is the dataType
	 * 2) the catchall symbol "*" can be used
	 * 3) selection will start with transport dataType and THEN go to "*" if needed
	 */
	transports = {},

// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
	allTypes = "*/".concat( "*" ),

// Anchor tag for parsing the document origin
	originAnchor = document.createElement( "a" );
	originAnchor.href = location.href;

// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
function addToPrefiltersOrTransports( structure ) {

// dataTypeExpression is optional and defaults to "*"
	return function( dataTypeExpression, func ) {

if ( typeof dataTypeExpression !== "string" ) {
			func = dataTypeExpression;
			dataTypeExpression = "*";
		}

var dataType,
			i = 0,
			dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];

if ( jQuery.isFunction( func ) ) {

// For each dataType in the dataTypeExpression
			while ( ( dataType = dataTypes[ i++ ] ) ) {

// Prepend if requested
				if ( dataType[ 0 ] === "+" ) {
					dataType = dataType.slice( 1 ) || "*";
					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );

// Otherwise append
				} else {
					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
				}
			}
		}
	};
}

// Base inspection function for prefilters and transports
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

var inspected = {},
		seekingTransport = ( structure === transports );

function inspect( dataType ) {
		var selected;
		inspected[ dataType ] = true;
		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
			if ( typeof dataTypeOrTransport === "string" &&
				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {

options.dataTypes.unshift( dataTypeOrTransport );
				inspect( dataTypeOrTransport );
				return false;
			} else if ( seekingTransport ) {
				return !( selected = dataTypeOrTransport );
			}
		} );
		return selected;
	}

return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
}

// A special extend for ajax options
// that takes "flat" options (not to be deep extended)
// Fixes #9887
function ajaxExtend( target, src ) {
	var key, deep,
		flatOptions = jQuery.ajaxSettings.flatOptions || {};

for ( key in src ) {
		if ( src[ key ] !== undefined ) {
			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
		}
	}
	if ( deep ) {
		jQuery.extend( true, target, deep );
	}

return target;
}

/* Handles responses to an ajax request:
 * - finds the right dataType (mediates between content-type and expected dataType)
 * - returns the corresponding response
 */
function ajaxHandleResponses( s, jqXHR, responses ) {

var ct, type, finalDataType, firstDataType,
		contents = s.contents,
		dataTypes = s.dataTypes;

// Remove auto dataType and get content-type in the process
	while ( dataTypes[ 0 ] === "*" ) {
		dataTypes.shift();
		if ( ct === undefined ) {
			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
		}
	}

// Check if we're dealing with a known content-type
	if ( ct ) {
		for ( type in contents ) {
			if ( contents[ type ] && contents[ type ].test( ct ) ) {
				dataTypes.unshift( type );
				break;
			}
		}
	}

// Check to see if we have a response for the expected dataType
	if ( dataTypes[ 0 ] in responses ) {
		finalDataType = dataTypes[ 0 ];
	} else {

// Try convertible dataTypes
		for ( type in responses ) {
			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
				finalDataType = type;
				break;
			}
			if ( !firstDataType ) {
				firstDataType = type;
			}
		}

// Or just use first one
		finalDataType = finalDataType || firstDataType;
	}

// If we found a dataType
	// We add the dataType to the list if needed
	// and return the corresponding response
	if ( finalDataType ) {
		if ( finalDataType !== dataTypes[ 0 ] ) {
			dataTypes.unshift( finalDataType );
		}
		return responses[ finalDataType ];
	}
}

/* Chain conversions given the request and the original response
 * Also sets the responseXXX fields on the jqXHR instance
 */
function ajaxConvert( s, response, jqXHR, isSuccess ) {
	var conv2, current, conv, tmp, prev,
		converters = {},

// Work with a copy of dataTypes in case we need to modify it for conversion
		dataTypes = s.dataTypes.slice();

// Create converters map with lowercased keys
	if ( dataTypes[ 1 ] ) {
		for ( conv in s.converters ) {
			converters[ conv.toLowerCase() ] = s.converters[ conv ];
		}
	}

current = dataTypes.shift();

// Convert to each sequential dataType
	while ( current ) {

if ( s.responseFields[ current ] ) {
			jqXHR[ s.responseFields[ current ] ] = response;
		}

// Apply the dataFilter if provided
		if ( !prev && isSuccess && s.dataFilter ) {
			response = s.dataFilter( response, s.dataType );
		}

prev = current;
		current = dataTypes.shift();

if ( current ) {

// There's only work to do if current dataType is non-auto
			if ( current === "*" ) {

current = prev;

// Convert response if prev dataType is non-auto and differs from current
			} else if ( prev !== "*" && prev !== current ) {

// Seek a direct converter
				conv = converters[ prev + " " + current ] || converters[ "* " + current ];

// If none found, seek a pair
				if ( !conv ) {
					for ( conv2 in converters ) {

// If conv2 outputs current
						tmp = conv2.split( " " );
						if ( tmp[ 1 ] === current ) {

// If prev can be converted to accepted input
							conv = converters[ prev + " " + tmp[ 0 ] ] ||
								converters[ "* " + tmp[ 0 ] ];
							if ( conv ) {

// Condense equivalence converters
								if ( conv === true ) {
									conv = converters[ conv2 ];

// Otherwise, insert the intermediate dataType
								} else if ( converters[ conv2 ] !== true ) {
									current = tmp[ 0 ];
									dataTypes.unshift( tmp[ 1 ] );
								}
								break;
							}
						}
					}
				}

// Apply converter (if not an equivalence)
				if ( conv !== true ) {

// Unless errors are allowed to bubble, catch and return them
					if ( conv && s.throws ) {
						response = conv( response );
					} else {
						try {
							response = conv( response );
						} catch ( e ) {
							return {
								state: "parsererror",
								error: conv ? e : "No conversion from " + prev + " to " + current
							};
						}
					}
				}
			}
		}
	}

return { state: "success", data: response };
}

jQuery.extend( {

// Counter for holding the number of active queries
	active: 0,

// Last-Modified header cache for next request
	lastModified: {},
	etag: {},

ajaxSettings: {
		url: location.href,
		type: "GET",
		isLocal: rlocalProtocol.test( location.protocol ),
		global: true,
		processData: true,
		async: true,
		contentType: "application/x-www-form-urlencoded; charset=UTF-8",

/*
		timeout: 0,
		data: null,
		dataType: null,
		username: null,
		password: null,
		cache: null,
		throws: false,
		traditional: false,
		headers: {},
		*/

accepts: {
			"*": allTypes,
			text: "text/plain",
			html: "text/html",
			xml: "application/xml, text/xml",
			json: "application/json, text/javascript"
		},

contents: {
			xml: /\bxml\b/,
			html: /\bhtml/,
			json: /\bjson\b/
		},

responseFields: {
			xml: "responseXML",
			text: "responseText",
			json: "responseJSON"
		},

// Data converters
		// Keys separate source (or catchall "*") and destination types with a single space
		converters: {

// Convert anything to text
			"* text": String,

// Text to html (true = no transformation)
			"text html": true,

// Evaluate text as a json expression
			"text json": JSON.parse,

// Parse text as xml
			"text xml": jQuery.parseXML
		},

// For options that shouldn't be deep extended:
		// you can add your own custom options here if
		// and when you create one that shouldn't be
		// deep extended (see ajaxExtend)
		flatOptions: {
			url: true,
			context: true
		}
	},

// Creates a full fledged settings object into target
	// with both ajaxSettings and settings fields.
	// If target is omitted, writes into ajaxSettings.
	ajaxSetup: function( target, settings ) {
		return settings ?

// Building a settings object
			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :

// Extending ajaxSettings
			ajaxExtend( jQuery.ajaxSettings, target );
	},

ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
	ajaxTransport: addToPrefiltersOrTransports( transports ),

// Main method
	ajax: function( url, options ) {

// If url is an object, simulate pre-1.5 signature
		if ( typeof url === "object" ) {
			options = url;
			url = undefined;
		}

// Force options to be an object
		options = options || {};

var transport,

// URL without anti-cache param
			cacheURL,

// Response headers
			responseHeadersString,
			responseHeaders,

// timeout handle
			timeoutTimer,

// Url cleanup var
			urlAnchor,

// Request state (becomes false upon send and true upon completion)
			completed,

// To know if global events are to be dispatched
			fireGlobals,

// Loop variable
			i,

// uncached part of the url
			uncached,

// Create the final options object
			s = jQuery.ajaxSetup( {}, options ),

// Callbacks context
			callbackContext = s.context || s,

// Context for global events is callbackContext if it is a DOM node or jQuery collection
			globalEventContext = s.context &&
				( callbackContext.nodeType || callbackContext.jquery ) ?
					jQuery( callbackContext ) :
					jQuery.event,

// Deferreds
			deferred = jQuery.Deferred(),
			completeDeferred = jQuery.Callbacks( "once memory" ),

// Status-dependent callbacks
			statusCode = s.statusCode || {},

// Headers (they are sent all at once)
			requestHeaders = {},
			requestHeadersNames = {},

// Default abort message
			strAbort = "canceled",

// Fake xhr
			jqXHR = {
				readyState: 0,

// Builds headers hashtable if needed
				getResponseHeader: function( key ) {
					var match;
					if ( completed ) {
						if ( !responseHeaders ) {
							responseHeaders = {};
							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
								responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
							}
						}
						match = responseHeaders[ key.toLowerCase() ];
					}
					return match == null ? null : match;
				},

// Raw string
				getAllResponseHeaders: function() {
					return completed ? responseHeadersString : null;
				},

// Caches the header
				setRequestHeader: function( name, value ) {
					if ( completed == null ) {
						name = requestHeadersNames[ name.toLowerCase() ] =
							requestHeadersNames[ name.toLowerCase() ] || name;
						requestHeaders[ name ] = value;
					}
					return this;
				},

// Overrides response content-type header
				overrideMimeType: function( type ) {
					if ( completed == null ) {
						s.mimeType = type;
					}
					return this;
				},

// Status-dependent callbacks
				statusCode: function( map ) {
					var code;
					if ( map ) {
						if ( completed ) {

// Execute the appropriate callbacks
							jqXHR.always( map[ jqXHR.status ] );
						} else {

// Lazy-add the new callbacks in a way that preserves old ones
							for ( code in map ) {
								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
							}
						}
					}
					return this;
				},

// Cancel the request
				abort: function( statusText ) {
					var finalText = statusText || strAbort;
					if ( transport ) {
						transport.abort( finalText );
					}
					done( 0, finalText );
					return this;
				}
			};

// Attach deferreds
		deferred.promise( jqXHR );

// Add protocol if not provided (prefilters might expect it)
		// Handle falsy url in the settings object (#10093: consistency with old signature)
		// We also use the url parameter if available
		s.url = ( ( url || s.url || location.href ) + "" )
			.replace( rprotocol, location.protocol + "//" );

// Alias method option to type as per ticket #12004
		s.type = options.method || options.type || s.method || s.type;

// Extract dataTypes list
		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];

// A cross-domain request is in order when the origin doesn't match the current origin.
		if ( s.crossDomain == null ) {
			urlAnchor = document.createElement( "a" );

// Support: IE <=8 - 11, Edge 12 - 13
			// IE throws exception on accessing the href property if url is malformed,
			// e.g. http://example.com:80x/
			try {
				urlAnchor.href = s.url;

// Support: IE <=8 - 11 only
				// Anchor's host property isn't correctly set when s.url is relative
				urlAnchor.href = urlAnchor.href;
				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
					urlAnchor.protocol + "//" + urlAnchor.host;
			} catch ( e ) {

// If there is an error parsing the URL, assume it is crossDomain,
				// it can be rejected by the transport if it is invalid
				s.crossDomain = true;
			}
		}

// Convert data if not already a string
		if ( s.data && s.processData && typeof s.data !== "string" ) {
			s.data = jQuery.param( s.data, s.traditional );
		}

// Apply prefilters
		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );

// If request was aborted inside a prefilter, stop there
		if ( completed ) {
			return jqXHR;
		}

// We can fire global events as of now if asked to
		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
		fireGlobals = jQuery.event && s.global;

// Watch for a new set of requests
		if ( fireGlobals && jQuery.active++ === 0 ) {
			jQuery.event.trigger( "ajaxStart" );
		}

// Uppercase the type
		s.type = s.type.toUpperCase();

// Determine if request has content
		s.hasContent = !rnoContent.test( s.type );

// Save the URL in case we're toying with the If-Modified-Since
		// and/or If-None-Match header later on
		// Remove hash to simplify url manipulation
		cacheURL = s.url.replace( rhash, "" );

// More options handling for requests with no content
		if ( !s.hasContent ) {

// Remember the hash so we can put it back
			uncached = s.url.slice( cacheURL.length );

// If data is available, append data to url
			if ( s.data ) {
				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;

// #9682: remove data so that it's not used in an eventual retry
				delete s.data;
			}

// Add anti-cache in uncached url if needed
			if ( s.cache === false ) {
				cacheURL = cacheURL.replace( rts, "" );
				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
			}

// Put hash and anti-cache on the URL that will be requested (gh-1732)
			s.url = cacheURL + uncached;

// Change '%20' to '+' if this is encoded form body content (gh-2658)
		} else if ( s.data && s.processData &&
			( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
			s.data = s.data.replace( r20, "+" );
		}

// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
		if ( s.ifModified ) {
			if ( jQuery.lastModified[ cacheURL ] ) {
				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
			}
			if ( jQuery.etag[ cacheURL ] ) {
				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
			}
		}

// Set the correct header, if data is being sent
		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
			jqXHR.setRequestHeader( "Content-Type", s.contentType );
		}

// Set the Accepts header for the server, depending on the dataType
		jqXHR.setRequestHeader(
			"Accept",
			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
				s.accepts[ s.dataTypes[ 0 ] ] +
					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
				s.accepts[ "*" ]
		);

// Check for headers option
		for ( i in s.headers ) {
			jqXHR.setRequestHeader( i, s.headers[ i ] );
		}

// Allow custom headers/mimetypes and early abort
		if ( s.beforeSend &&
			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {

// Abort if not done already and return
			return jqXHR.abort();
		}

// Aborting is no longer a cancellation
		strAbort = "abort";

// Install callbacks on deferreds
		completeDeferred.add( s.complete );
		jqXHR.done( s.success );
		jqXHR.fail( s.error );

// Get transport
		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );

// If no transport, we auto-abort
		if ( !transport ) {
			done( -1, "No Transport" );
		} else {
			jqXHR.readyState = 1;

// Send global event
			if ( fireGlobals ) {
				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
			}

// If request was aborted inside ajaxSend, stop there
			if ( completed ) {
				return jqXHR;
			}

// Timeout
			if ( s.async && s.timeout > 0 ) {
				timeoutTimer = window.setTimeout( function() {
					jqXHR.abort( "timeout" );
				}, s.timeout );
			}

try {
				completed = false;
				transport.send( requestHeaders, done );
			} catch ( e ) {

// Rethrow post-completion exceptions
				if ( completed ) {
					throw e;
				}

// Propagate others as results
				done( -1, e );
			}
		}

// Callback for when everything is done
		function done( status, nativeStatusText, responses, headers ) {
			var isSuccess, success, error, response, modified,
				statusText = nativeStatusText;

// Ignore repeat invocations
			if ( completed ) {
				return;
			}

completed = true;

// Clear timeout if it exists
			if ( timeoutTimer ) {
				window.clearTimeout( timeoutTimer );
			}

// Dereference transport for early garbage collection
			// (no matter how long the jqXHR object will be used)
			transport = undefined;

// Cache response headers
			responseHeadersString = headers || "";

// Set readyState
			jqXHR.readyState = status > 0 ? 4 : 0;

// Determine if successful
			isSuccess = status >= 200 && status < 300 || status === 304;

// Get response data
			if ( responses ) {
				response = ajaxHandleResponses( s, jqXHR, responses );
			}

// Convert no matter what (that way responseXXX fields are always set)
			response = ajaxConvert( s, response, jqXHR, isSuccess );

// If successful, handle type chaining
			if ( isSuccess ) {

// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
				if ( s.ifModified ) {
					modified = jqXHR.getResponseHeader( "Last-Modified" );
					if ( modified ) {
						jQuery.lastModified[ cacheURL ] = modified;
					}
					modified = jqXHR.getResponseHeader( "etag" );
					if ( modified ) {
						jQuery.etag[ cacheURL ] = modified;
					}
				}

// if no content
				if ( status === 204 || s.type === "HEAD" ) {
					statusText = "nocontent";

// if not modified
				} else if ( status === 304 ) {
					statusText = "notmodified";

// If we have data, let's convert it
				} else {
					statusText = response.state;
					success = response.data;
					error = response.error;
					isSuccess = !error;
				}
			} else {

// Extract error from statusText and normalize for non-aborts
				error = statusText;
				if ( status || !statusText ) {
					statusText = "error";
					if ( status < 0 ) {
						status = 0;
					}
				}
			}

// Set data for the fake xhr object
			jqXHR.status = status;
			jqXHR.statusText = ( nativeStatusText || statusText ) + "";

// Success/Error
			if ( isSuccess ) {
				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
			} else {
				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
			}

// Status-dependent callbacks
			jqXHR.statusCode( statusCode );
			statusCode = undefined;

if ( fireGlobals ) {
				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
					[ jqXHR, s, isSuccess ? success : error ] );
			}

// Complete
			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );

if ( fireGlobals ) {
				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );

// Handle the global AJAX counter
				if ( !( --jQuery.active ) ) {
					jQuery.event.trigger( "ajaxStop" );
				}
			}
		}

return jqXHR;
	},

getJSON: function( url, data, callback ) {
		return jQuery.get( url, data, callback, "json" );
	},

getScript: function( url, callback ) {
		return jQuery.get( url, undefined, callback, "script" );
	}
} );

jQuery.each( [ "get", "post" ], function( i, method ) {
	jQuery[ method ] = function( url, data, callback, type ) {

// Shift arguments if data argument was omitted
		if ( jQuery.isFunction( data ) ) {
			type = type || callback;
			callback = data;
			data = undefined;
		}

// The url can be an options object (which then must have .url)
		return jQuery.ajax( jQuery.extend( {
			url: url,
			type: method,
			dataType: type,
			data: data,
			success: callback
		}, jQuery.isPlainObject( url ) && url ) );
	};
} );

jQuery._evalUrl = function( url ) {
	return jQuery.ajax( {
		url: url,

// Make this explicit, since user can override this through ajaxSetup (#11264)
		type: "GET",
		dataType: "script",
		cache: true,
		async: false,
		global: false,
		"throws": true
	} );
};

jQuery.fn.extend( {
	wrapAll: function( html ) {
		var wrap;

if ( this[ 0 ] ) {
			if ( jQuery.isFunction( html ) ) {
				html = html.call( this[ 0 ] );
			}

// The elements to wrap the target around
			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );

if ( this[ 0 ].parentNode ) {
				wrap.insertBefore( this[ 0 ] );
			}

wrap.map( function() {
				var elem = this;

while ( elem.firstElementChild ) {
					elem = elem.firstElementChild;
				}

return elem;
			} ).append( this );
		}

return this;
	},

wrapInner: function( html ) {
		if ( jQuery.isFunction( html ) ) {
			return this.each( function( i ) {
				jQuery( this ).wrapInner( html.call( this, i ) );
			} );
		}

return this.each( function() {
			var self = jQuery( this ),
				contents = self.contents();

if ( contents.length ) {
				contents.wrapAll( html );

} else {
				self.append( html );
			}
		} );
	},

wrap: function( html ) {
		var isFunction = jQuery.isFunction( html );

return this.each( function( i ) {
			jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
		} );
	},

unwrap: function( selector ) {
		this.parent( selector ).not( "body" ).each( function() {
			jQuery( this ).replaceWith( this.childNodes );
		} );
		return this;
	}
} );

jQuery.expr.pseudos.hidden = function( elem ) {
	return !jQuery.expr.pseudos.visible( elem );
};
jQuery.expr.pseudos.visible = function( elem ) {
	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
};

jQuery.ajaxSettings.xhr = function() {
	try {
		return new window.XMLHttpRequest();
	} catch ( e ) {}
};

var xhrSuccessStatus = {

// File protocol always yields status code 0, assume 200
		0: 200,

// Support: IE <=9 only
		// #1450: sometimes IE returns 1223 when it should be 204
		1223: 204
	},
	xhrSupported = jQuery.ajaxSettings.xhr();

support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
support.ajax = xhrSupported = !!xhrSupported;

jQuery.ajaxTransport( function( options ) {
	var callback, errorCallback;

// Cross domain only allowed if supported through XMLHttpRequest
	if ( support.cors || xhrSupported && !options.crossDomain ) {
		return {
			send: function( headers, complete ) {
				var i,
					xhr = options.xhr();

xhr.open(
					options.type,
					options.url,
					options.async,
					options.username,
					options.password
				);

// Apply custom fields if provided
				if ( options.xhrFields ) {
					for ( i in options.xhrFields ) {
						xhr[ i ] = options.xhrFields[ i ];
					}
				}

// Override mime type if needed
				if ( options.mimeType && xhr.overrideMimeType ) {
					xhr.overrideMimeType( options.mimeType );
				}

// X-Requested-With header
				// For cross-domain requests, seeing as conditions for a preflight are
				// akin to a jigsaw puzzle, we simply never set it to be sure.
				// (it can always be set on a per-request basis or even using ajaxSetup)
				// For same-domain requests, won't change header if already provided.
				if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
					headers[ "X-Requested-With" ] = "XMLHttpRequest";
				}

// Set headers
				for ( i in headers ) {
					xhr.setRequestHeader( i, headers[ i ] );
				}

// Callback
				callback = function( type ) {
					return function() {
						if ( callback ) {
							callback = errorCallback = xhr.onload =
								xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;

if ( type === "abort" ) {
								xhr.abort();
							} else if ( type === "error" ) {

// Support: IE <=9 only
								// On a manual native abort, IE9 throws
								// errors on any property access that is not readyState
								if ( typeof xhr.status !== "number" ) {
									complete( 0, "error" );
								} else {
									complete(

// File: protocol always yields status 0; see #8605, #14207
										xhr.status,
										xhr.statusText
									);
								}
							} else {
								complete(
									xhrSuccessStatus[ xhr.status ] || xhr.status,
									xhr.statusText,

// Support: IE <=9 only
									// IE9 has no XHR2 but throws on binary (trac-11426)
									// For XHR2 non-text, let the caller handle it (gh-2498)
									( xhr.responseType || "text" ) !== "text"  ||
									typeof xhr.responseText !== "string" ?
										{ binary: xhr.response } :
										{ text: xhr.responseText },
									xhr.getAllResponseHeaders()
								);
							}
						}
					};
				};

// Listen to events
				xhr.onload = callback();
				errorCallback = xhr.onerror = callback( "error" );

// Support: IE 9 only
				// Use onreadystatechange to replace onabort
				// to handle uncaught aborts
				if ( xhr.onabort !== undefined ) {
					xhr.onabort = errorCallback;
				} else {
					xhr.onreadystatechange = function() {

// Check readyState before timeout as it changes
						if ( xhr.readyState === 4 ) {

// Allow onerror to be called first,
							// but that will not handle a native abort
							// Also, save errorCallback to a variable
							// as xhr.onerror cannot be accessed
							window.setTimeout( function() {
								if ( callback ) {
									errorCallback();
								}
							} );
						}
					};
				}

// Create the abort callback
				callback = callback( "abort" );

try {

// Do send the request (this may raise an exception)
					xhr.send( options.hasContent && options.data || null );
				} catch ( e ) {

// #14683: Only rethrow if this hasn't been notified as an error yet
					if ( callback ) {
						throw e;
					}
				}
			},

abort: function() {
				if ( callback ) {
					callback();
				}
			}
		};
	}
} );

// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
jQuery.ajaxPrefilter( function( s ) {
	if ( s.crossDomain ) {
		s.contents.script = false;
	}
} );

// Install script dataType
jQuery.ajaxSetup( {
	accepts: {
		script: "text/javascript, application/javascript, " +
			"application/ecmascript, application/x-ecmascript"
	},
	contents: {
		script: /\b(?:java|ecma)script\b/
	},
	converters: {
		"text script": function( text ) {
			jQuery.globalEval( text );
			return text;
		}
	}
} );

// Handle cache's special case and crossDomain
jQuery.ajaxPrefilter( "script", function( s ) {
	if ( s.cache === undefined ) {
		s.cache = false;
	}
	if ( s.crossDomain ) {
		s.type = "GET";
	}
} );

// Bind script tag hack transport
jQuery.ajaxTransport( "script", function( s ) {

// This transport only deals with cross domain requests
	if ( s.crossDomain ) {
		var script, callback;
		return {
			send: function( _, complete ) {
				script = jQuery( "<script>" ).prop( {
					charset: s.scriptCharset,
					src: s.url
				} ).on(
					"load error",
					callback = function( evt ) {
						script.remove();
						callback = null;
						if ( evt ) {
							complete( evt.type === "error" ? 404 : 200, evt.type );
						}
					}
				);

// Use native DOM manipulation to avoid our domManip AJAX trickery
				document.head.appendChild( script[ 0 ] );
			},
			abort: function() {
				if ( callback ) {
					callback();
				}
			}
		};
	}
} );

var oldCallbacks = [],
	rjsonp = /(=)\?(?=&|$)|\?\?/;

// Default jsonp settings
jQuery.ajaxSetup( {
	jsonp: "callback",
	jsonpCallback: function() {
		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
		this[ callback ] = true;
		return callback;
	}
} );

// Detect, normalize options and install callbacks for jsonp requests
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {

var callbackName, overwritten, responseContainer,
		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
			"url" :
			typeof s.data === "string" &&
				( s.contentType || "" )
					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
				rjsonp.test( s.data ) && "data"
		);

// Handle iff the expected data type is "jsonp" or we have a parameter to set
	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {

// Get callback name, remembering preexisting value associated with it
		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
			s.jsonpCallback() :
			s.jsonpCallback;

// Insert callback into url or form data
		if ( jsonProp ) {
			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
		} else if ( s.jsonp !== false ) {
			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
		}

// Use data converter to retrieve json after script execution
		s.converters[ "script json" ] = function() {
			if ( !responseContainer ) {
				jQuery.error( callbackName + " was not called" );
			}
			return responseContainer[ 0 ];
		};

// Force json dataType
		s.dataTypes[ 0 ] = "json";

// Install callback
		overwritten = window[ callbackName ];
		window[ callbackName ] = function() {
			responseContainer = arguments;
		};

// Clean-up function (fires after converters)
		jqXHR.always( function() {

// If previous value didn't exist - remove it
			if ( overwritten === undefined ) {
				jQuery( window ).removeProp( callbackName );

// Otherwise restore preexisting value
			} else {
				window[ callbackName ] = overwritten;
			}

// Save back as free
			if ( s[ callbackName ] ) {

// Make sure that re-using the options doesn't screw things around
				s.jsonpCallback = originalSettings.jsonpCallback;

// Save the callback name for future use
				oldCallbacks.push( callbackName );
			}

// Call if it was a function and we have a response
			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
				overwritten( responseContainer[ 0 ] );
			}

responseContainer = overwritten = undefined;
		} );

// Delegate to script
		return "script";
	}
} );

// Support: Safari 8 only
// In Safari 8 documents created via document.implementation.createHTMLDocument
// collapse sibling forms: the second one becomes a child of the first one.
// Because of that, this security measure has to be disabled in Safari 8.
// https://bugs.webkit.org/show_bug.cgi?id=137337
support.createHTMLDocument = ( function() {
	var body = document.implementation.createHTMLDocument( "" ).body;
	body.innerHTML = "<form></form><form></form>";
	return body.childNodes.length === 2;
} )();

// Argument "data" should be string of html
// context (optional): If specified, the fragment will be created in this context,
// defaults to document
// keepScripts (optional): If true, will include scripts passed in the html string
jQuery.parseHTML = function( data, context, keepScripts ) {
	if ( typeof data !== "string" ) {
		return [];
	}
	if ( typeof context === "boolean" ) {
		keepScripts = context;
		context = false;
	}

var base, parsed, scripts;

if ( !context ) {

// Stop scripts or inline event handlers from being executed immediately
		// by using document.implementation
		if ( support.createHTMLDocument ) {
			context = document.implementation.createHTMLDocument( "" );

// Set the base href for the created document
			// so any parsed elements with URLs
			// are based on the document's URL (gh-2965)
			base = context.createElement( "base" );
			base.href = document.location.href;
			context.head.appendChild( base );
		} else {
			context = document;
		}
	}

parsed = rsingleTag.exec( data );
	scripts = !keepScripts && [];

// Single tag
	if ( parsed ) {
		return [ context.createElement( parsed[ 1 ] ) ];
	}

parsed = buildFragment( [ data ], context, scripts );

if ( scripts && scripts.length ) {
		jQuery( scripts ).remove();
	}

return jQuery.merge( [], parsed.childNodes );
};

/**
 * Load a url into a page
 */
jQuery.fn.load = function( url, params, callback ) {
	var selector, type, response,
		self = this,
		off = url.indexOf( " " );

if ( off > -1 ) {
		selector = jQuery.trim( url.slice( off ) );
		url = url.slice( 0, off );
	}

// If it's a function
	if ( jQuery.isFunction( params ) ) {

// We assume that it's the callback
		callback = params;
		params = undefined;

// Otherwise, build a param string
	} else if ( params && typeof params === "object" ) {
		type = "POST";
	}

// If we have elements to modify, make the request
	if ( self.length > 0 ) {
		jQuery.ajax( {
			url: url,

// If "type" variable is undefined, then "GET" method will be used.
			// Make value of this field explicit since
			// user can override it through ajaxSetup method
			type: type || "GET",
			dataType: "html",
			data: params
		} ).done( function( responseText ) {

// Save response for use in complete callback
			response = arguments;

self.html( selector ?

// If a selector was specified, locate the right elements in a dummy div
				// Exclude scripts to avoid IE 'Permission Denied' errors
				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :

// Otherwise use the full result
				responseText );

// If the request succeeds, this function gets "data", "status", "jqXHR"
		// but they are ignored because response was set above.
		// If it fails, this function gets "jqXHR", "status", "error"
		} ).always( callback && function( jqXHR, status ) {
			self.each( function() {
				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
			} );
		} );
	}

return this;
};

// Attach a bunch of functions for handling common AJAX events
jQuery.each( [
	"ajaxStart",
	"ajaxStop",
	"ajaxComplete",
	"ajaxError",
	"ajaxSuccess",
	"ajaxSend"
], function( i, type ) {
	jQuery.fn[ type ] = function( fn ) {
		return this.on( type, fn );
	};
} );

jQuery.expr.pseudos.animated = function( elem ) {
	return jQuery.grep( jQuery.timers, function( fn ) {
		return elem === fn.elem;
	} ).length;
};

/**
 * Gets a window from an element
 */
function getWindow( elem ) {
	return jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 && elem.defaultView;
}

jQuery.offset = {
	setOffset: function( elem, options, i ) {
		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
			position = jQuery.css( elem, "position" ),
			curElem = jQuery( elem ),
			props = {};

// Set position first, in-case top/left are set even on static elem
		if ( position === "static" ) {
			elem.style.position = "relative";
		}

curOffset = curElem.offset();
		curCSSTop = jQuery.css( elem, "top" );
		curCSSLeft = jQuery.css( elem, "left" );
		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;

// Need to be able to calculate position if either
		// top or left is auto and position is either absolute or fixed
		if ( calculatePosition ) {
			curPosition = curElem.position();
			curTop = curPosition.top;
			curLeft = curPosition.left;

} else {
			curTop = parseFloat( curCSSTop ) || 0;
			curLeft = parseFloat( curCSSLeft ) || 0;
		}

if ( jQuery.isFunction( options ) ) {

// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
		}

if ( options.top != null ) {
			props.top = ( options.top - curOffset.top ) + curTop;
		}
		if ( options.left != null ) {
			props.left = ( options.left - curOffset.left ) + curLeft;
		}

if ( "using" in options ) {
			options.using.call( elem, props );

} else {
			curElem.css( props );
		}
	}
};

jQuery.fn.extend( {
	offset: function( options ) {

// Preserve chaining for setter
		if ( arguments.length ) {
			return options === undefined ?
				this :
				this.each( function( i ) {
					jQuery.offset.setOffset( this, options, i );
				} );
		}

var docElem, win, rect, doc,
			elem = this[ 0 ];

if ( !elem ) {
			return;
		}

// Support: IE <=11 only
		// Running getBoundingClientRect on a
		// disconnected node in IE throws an error
		if ( !elem.getClientRects().length ) {
			return { top: 0, left: 0 };
		}

rect = elem.getBoundingClientRect();

// Make sure element is not hidden (display: none)
		if ( rect.width || rect.height ) {
			doc = elem.ownerDocument;
			win = getWindow( doc );
			docElem = doc.documentElement;

return {
				top: rect.top + win.pageYOffset - docElem.clientTop,
				left: rect.left + win.pageXOffset - docElem.clientLeft
			};
		}

// Return zeros for disconnected and hidden elements (gh-2310)
		return rect;
	},

position: function() {
		if ( !this[ 0 ] ) {
			return;
		}

var offsetParent, offset,
			elem = this[ 0 ],
			parentOffset = { top: 0, left: 0 };

// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
		// because it is its only offset parent
		if ( jQuery.css( elem, "position" ) === "fixed" ) {

// Assume getBoundingClientRect is there when computed position is fixed
			offset = elem.getBoundingClientRect();

} else {

// Get *real* offsetParent
			offsetParent = this.offsetParent();

// Get correct offsets
			offset = this.offset();
			if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
				parentOffset = offsetParent.offset();
			}

// Add offsetParent borders
			parentOffset = {
				top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
				left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
			};
		}

// Subtract parent offsets and element margins
		return {
			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
		};
	},

// This method will return documentElement in the following cases:
	// 1) For the element inside the iframe without offsetParent, this method will return
	//    documentElement of the parent window
	// 2) For the hidden or detached element
	// 3) For body or html element, i.e. in case of the html node - it will return itself
	//
	// but those exceptions were never presented as a real life use-cases
	// and might be considered as more preferable results.
	//
	// This logic, however, is not guaranteed and can change at any point in the future
	offsetParent: function() {
		return this.map( function() {
			var offsetParent = this.offsetParent;

while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
				offsetParent = offsetParent.offsetParent;
			}

return offsetParent || documentElement;
		} );
	}
} );

// Create scrollLeft and scrollTop methods
jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
	var top = "pageYOffset" === prop;

jQuery.fn[ method ] = function( val ) {
		return access( this, function( elem, method, val ) {
			var win = getWindow( elem );

if ( val === undefined ) {
				return win ? win[ prop ] : elem[ method ];
			}

if ( win ) {
				win.scrollTo(
					!top ? val : win.pageXOffset,
					top ? val : win.pageYOffset
				);

} else {
				elem[ method ] = val;
			}
		}, method, val, arguments.length );
	};
} );

// Support: Safari <=7 - 9.1, Chrome <=37 - 49
// Add the top/left cssHooks using jQuery.fn.position
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
// getComputedStyle returns percent when specified for top/left/bottom/right;
// rather than make the css module depend on the offset module, just check for it here
jQuery.each( [ "top", "left" ], function( i, prop ) {
	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
		function( elem, computed ) {
			if ( computed ) {
				computed = curCSS( elem, prop );

// If curCSS returns percentage, fallback to offset
				return rnumnonpx.test( computed ) ?
					jQuery( elem ).position()[ prop ] + "px" :
					computed;
			}
		}
	);
} );

// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
		function( defaultExtra, funcName ) {

// Margin is only for outerHeight, outerWidth
		jQuery.fn[ funcName ] = function( margin, value ) {
			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );

return access( this, function( elem, type, value ) {
				var doc;

if ( jQuery.isWindow( elem ) ) {

// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
					return funcName.indexOf( "outer" ) === 0 ?
						elem[ "inner" + name ] :
						elem.document.documentElement[ "client" + name ];
				}

// Get document width or height
				if ( elem.nodeType === 9 ) {
					doc = elem.documentElement;

// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
					// whichever is greatest
					return Math.max(
						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
						elem.body[ "offset" + name ], doc[ "offset" + name ],
						doc[ "client" + name ]
					);
				}

return value === undefined ?

// Get width or height on the element, requesting but not forcing parseFloat
					jQuery.css( elem, type, extra ) :

// Set width or height on the element
					jQuery.style( elem, type, value, extra );
			}, type, chainable ? margin : undefined, chainable );
		};
	} );
} );

jQuery.fn.extend( {

bind: function( types, data, fn ) {
		return this.on( types, null, data, fn );
	},
	unbind: function( types, fn ) {
		return this.off( types, null, fn );
	},

delegate: function( selector, types, data, fn ) {
		return this.on( types, selector, data, fn );
	},
	undelegate: function( selector, types, fn ) {

// ( namespace ) or ( selector, types [, fn] )
		return arguments.length === 1 ?
			this.off( selector, "**" ) :
			this.off( types, selector || "**", fn );
	}
} );

jQuery.parseJSON = JSON.parse;

// Register as a named AMD module, since jQuery can be concatenated with other
// files that may use define, but not via a proper concatenation script that
// understands anonymous AMD modules. A named AMD is safest and most robust
// way to register. Lowercase jquery is used because AMD module names are
// derived from file names, and jQuery is normally delivered in a lowercase
// file name. Do this after creating the global so that if an AMD module wants
// to call noConflict to hide this version of jQuery, it will work.

// Note that for maximum portability, libraries that are not jQuery should
// declare themselves as anonymous modules, and avoid setting a global if an
// AMD loader is present. jQuery is a special case. For more information, see
// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon

if ( true ) {
	!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
		return jQuery;
	}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
}

var

// Map over jQuery in case of overwrite
	_jQuery = window.jQuery,

// Map over the $ in case of overwrite
	_$ = window.$;

jQuery.noConflict = function( deep ) {
	if ( window.$ === jQuery ) {
		window.$ = _$;
	}

if ( deep && window.jQuery === jQuery ) {
		window.jQuery = _jQuery;
	}

return jQuery;
};

// Expose jQuery and $ identifiers, even in AMD
// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
// and CommonJS for browser emulators (#13566)
if ( !noGlobal ) {
	window.jQuery = window.$ = jQuery;
}

return jQuery;
} );

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var empty = __webpack_require__(182);
module.exports = function isEmpty(mixed_var) {

if (null == mixed_var || '0' === mixed_var || '' === mixed_var || 0 === mixed_var || 'none' === mixed_var || false === mixed_var || 'object' == (typeof mixed_var === 'undefined' ? 'undefined' : _typeof(mixed_var)) && empty(mixed_var)) {
		return true;
	}
	return false;
};

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(process) {/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

if (process.env.NODE_ENV !== 'production') {
  var ReactIs = __webpack_require__(306);

// By explicitly using `prop-types` you are opting into new development behavior.
  // http://fb.me/prop-types-in-prod
  var throwOnDirectAccess = true;
  module.exports = __webpack_require__(1114)(ReactIs.isElement, throwOnDirectAccess);
} else {
  // By explicitly using `prop-types` you are opting into new production behavior.
  // http://fb.me/prop-types-in-prod
  module.exports = __webpack_require__(1113)();
}

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {module.exports = global["ReactDOM"] = __webpack_require__(1236);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _assign = __webpack_require__(778);

var _assign2 = _interopRequireDefault(_assign);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _assign2.default || function (target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i];

for (var key in source) {
      if (Object.prototype.hasOwnProperty.call(source, key)) {
        target[key] = source[key];
      }
    }
  }

return target;
};

/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
  Copyright (c) 2017 Jed Watson.
  Licensed under the MIT License (MIT), see
  http://jedwatson.github.io/classnames
*/
/* global define */

(function () {
	'use strict';

var hasOwn = {}.hasOwnProperty;

function classNames () {
		var classes = [];

for (var i = 0; i < arguments.length; i++) {
			var arg = arguments[i];
			if (!arg) continue;

var argType = typeof arg;

if (argType === 'string' || argType === 'number') {
				classes.push(arg);
			} else if (Array.isArray(arg) && arg.length) {
				var inner = classNames.apply(null, arg);
				if (inner) {
					classes.push(inner);
				}
			} else if (argType === 'object') {
				for (var key in arg) {
					if (hasOwn.call(arg, key) && arg[key]) {
						classes.push(key);
					}
				}
			}
		}

return classes.join(' ');
	}

if (typeof module !== 'undefined' && module.exports) {
		classNames.default = classNames;
		module.exports = classNames;
	} else if (true) {
		// register as 'classnames', consistent with npm package name
		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {
			return classNames;
		}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	} else {
		window.classNames = classNames;
	}
}());

/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

exports.default = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var createStore = __webpack_require__(340).createStore,
    applyMiddleware = __webpack_require__(340).applyMiddleware,
    getModuleKeyPath = __webpack_require__(39),
    changeUuid = __webpack_require__(374),
    ReduxThunk = __webpack_require__(1434).default,
    getTargetPastePath = __webpack_require__(716),
    combineReducers = __webpack_require__(340).combineReducers,
    parseModuleOptions = __webpack_require__(364),
    getDropTargetPath = __webpack_require__(238),
    getPathFromSelectionState = __webpack_require__(97),
    getPathFromPosition = __webpack_require__(239),
    componentFinder = __webpack_require__(689),
    moduleObj = __webpack_require__(159),
    addRow = __webpack_require__(363),
    addNewSection = __webpack_require__(687),
    parseContent = __webpack_require__(722).default,
    addNewModule = __webpack_require__(686),
    getBuilderMode = __webpack_require__(367).default,
    getColumnWidth = __webpack_require__(712),
    modifyAttsBeforeAddModule = __webpack_require__(372),
    undoable = __webpack_require__(776),
    filterActions = function filterActions(action, currentState, previousHistory) {

var result = false;
    switch (action.type) {

case 'RESET_SPINNER':
        case 'REORDER_NEW':
        case 'COLUMNLAYOUT':
        case 'ADD_INITIAL_DATA':
        case 'ADD_PASTED_MODULES':
            result = true;
            break;

case 'DELETE_MODULE':
        case 'DUPLICATE':
            var isSubModule = 'sub_module' == action.moduleOptions.getIn([action.moduleName, 'type']),
                isAjaxModule = !action.moduleOptions.getIn([action.moduleName, 'is_built_in']);
            return !(isSubModule && isAjaxModule);

case 'PASTE_ATTS':
            return action.moduleOptions.getIn([action.moduleName, 'is_built_in']);

case 'ADD_MODULE':
            var isBuiltIn = action.moduleOptions.getIn([action.moduleName, 'is_built_in']);
            if (isBuiltIn) {
                return true;
            } else {
                return false;
            }

case 'EDIT_MODULE':
            if (action.shouldBeRecorded) {
                return true;
            } else {
                return false;
            }

default:
            return false;

}

return result;
};

function setBuilderMode(state) {

state = state || getBuilderMode();

return state;
}

function pageContent(state, action) {

var keyPath = [];

state = state || parseContent(tatsuConfig.content, tatsuConfig.module_options);

switch (action.type) {

case 'ADD_INITIAL_DATA':
            state = action.state;
            return state;

case 'ADDSECTION':

case 'PASTE_ATTS':
            if (Immutable.List.isList(action.path.get(0))) {
                action.path.forEach(function (curPath) {

var pathArray = getModuleKeyPath(curPath, '', ''),
                        moduleData = state.getIn(pathArray);
                    state = state.setIn(pathArray, moduleData.set('atts', moduleData.get('atts').merge(action.atts)));
                });
            } else {
                var pathArray = getModuleKeyPath(action.path, '', ''),
                    moduleData = state.getIn(pathArray);
                state = state.setIn(pathArray, moduleData.set('atts', moduleData.get('atts').merge(action.atts)));
            }
            return state;

case 'ADDROW':

case 'ADD_TEMPLATE':

state = state.set('inner', state.get('inner').concat(action.templateData));
            return state;

case 'ADD_TEMPLATE_AS_PRESET':
            var path = action.path,
                templates = action.templateList,
                pathArray = getModuleKeyPath(path, '', ''),
                removeIndex = path.last(),
                sections = state.get('inner'),
                preList,
                postList;
            preList = sections.slice(0, removeIndex);
            postList = sections.slice(removeIndex + 1);
            state = state.set('inner', preList.concat(templates, postList));
            return state;

case 'SET_PRESET':

var targetPath = action.path,
                insertIndex = targetPath.last(),
                preset = action.preset,
                insertPathArray = getModuleKeyPath(targetPath.pop(), '', 'inner'),
                deletePathArray = getModuleKeyPath(targetPath, '', '');
            state = state.deleteIn(deletePathArray);

preset.forEach(function (presetMap, index) {
                state = state.setIn(insertPathArray, state.getIn(insertPathArray).insert(insertIndex + index, presetMap));
            });
            return state;

case 'RESET_PRESET':

var targetPath = action.path,
                insertDeleteIndex = targetPath.last(),
                preset = action.preset,
                module = action.module,
                pathArray = getModuleKeyPath(targetPath.pop(), '', 'inner');
            preset.forEach(function (presetMap, index) {
                state = state.setIn(pathArray, state.getIn(pathArray).delete(insertDeleteIndex));
            });
            state = state.setIn(pathArray, state.getIn(pathArray).insert(insertDeleteIndex, module));
            return state;

case 'REORDER_NEW':
            var duplicatedModule,
                sourcePath = action.sourcePath,
                targetPath = action.targetPath,
                sourceModule,
                sourceGetInArray,
                targetGetInArray = getModuleKeyPath(targetPath, '', ''),
                insertIndex = targetGetInArray.pop();

if ('copy' == action.dropEffect) {
                if (Immutable.List.isList(sourcePath.get(0))) {
                    sourcePath.reverse().forEach(function (curPath) {

sourceGetInArray = getModuleKeyPath(curPath, '', '');
                        sourceModule = state.getIn(sourceGetInArray);
                        if ('tatsu_inner_row' == sourceModule.get('name') && 4 < targetPath.size) {
                            return;
                        }
                        duplicatedModule = changeUuid(sourceModule);
                        state = state.setIn(targetGetInArray, state.getIn(targetGetInArray).insert(insertIndex, duplicatedModule));
                    });
                } else {
                    sourceGetInArray = getModuleKeyPath(sourcePath, '', '');
                    sourceModule = state.getIn(sourceGetInArray);
                    if ('tatsu_inner_row' == sourceModule.get('name') && 4 < targetPath.size) {
                        return;
                    }
                    duplicatedModule = changeUuid(sourceModule);
                    state = state.setIn(targetGetInArray, state.getIn(targetGetInArray).insert(insertIndex, duplicatedModule));
                }
            } else {
                sourceGetInArray = getModuleKeyPath(sourcePath, '', '');
                sourceModule = state.getIn(sourceGetInArray);
                state = state.deleteIn(sourceGetInArray);
                state = state.setIn(targetGetInArray, state.getIn(targetGetInArray).insert(insertIndex, sourceModule));
            }
            return state;

case 'BUILTIN_MODULE_ADD':

var newModule = addNewModule.addModule(action.moduleOptions, action.name, ''),
                keyPath,
                insertIndex,
                path,
                columnKeyPath;
            if (1 == action.path.size % 2) {
                path = action.path.push(0);
                keyPath = getModuleKeyPath(path, '', '');
                state = state.setIn(keyPath, newModule);
            } else {
                path = action.path;
                insertIndex = path.get(path.size - 1);
                columnKeyPath = getModuleKeyPath(path.pop(), '', 'inner');
                state = state.setIn(columnKeyPath, state.getIn(columnKeyPath).insert(insertIndex, newModule));
            }
            return state;

case 'DELETE_COLUMN_CHILDREN':

var columnPath = action.path,
                getInArray = getModuleKeyPath(columnPath, '', ''),
                column = state.getIn(getInArray);
            if ('tatsu_column' === column.get('name')) {
                getInArray.push('inner');
                state = state.setIn(getInArray, Immutable.List());
            }
            return state;

// case 'SET_IS_FETCHING' :

//          var setInArray = getModuleKeyPath( action.path, '', '' );
        //          setInArray.push( 'isFetching' );
        //          state = state.setIn( setInArray, action.isFetching );
        //          return state;

case 'SHOW_DROP_PREVIEW':

var setInArray, resetInArray;
            if (0 != action.currentPath.size && !Immutable.is(action.newPath, action.currentPath)) {
                resetInArray = getModuleKeyPath(action.currentPath, '', 'dropPreview');
                state = state.deleteIn(resetInArray);
            }
            if (0 != action.newPath.size) {
                setInArray = getModuleKeyPath(action.newPath, '', 'dropPreview');
                state = state.setIn(setInArray, action.position);
            }
            return state;

case 'EDIT_MODULE':

if (Immutable.List.isList(action.path.get(0))) {
                action.path.forEach(function (curPath) {

var pathArray = getModuleKeyPath(curPath, '', ''),
                        moduleData = state.getIn(pathArray);

if ('gutter' == action.attName || 'column_spacing' == action.attName) {
                        var columns = state.getIn(pathArray).get('inner');
                        columns = columns.map(function (column) {

if (action.targetDisplay.charAt('0') == 'd' && moduleName !== 'tatsu_inner_column' && action.attName === 'column_width') {
                    //Adjust Column Width of all columns in the Row

var columnPath = getModuleKeyPath(action.path, '', ''),
                        rowPath = Immutable.List(columnPath).pop(),
                        columnDetails = modifyColWidth(state, pathArray, columnPath, action.attValue, action.targetDisplay);

columnDetails.columnsWidth.map(function (value, index) {

if ('tatsu_image' == moduleData.get('name') && 'image' == action.attName && '' == action.attValue) {
                        pathArray.pop();
                        pathArray.push('image_varying_size_src');
                        state = state.setIn(pathArray, '');
                    }
                }
            }
            return state;

case 'CHANGE_TITLE':

var getInArray = getModuleKeyPath(action.path, '', 'atts');
            getInArray.push('section_title');
            state = state.setIn(getInArray, action.title);
            return state;

case 'MODULE_FETCH':

var getInArray = getModuleKeyPath(action.path, '', '');
            targetModule = state.getIn(getInArray), targetModule = targetModule.set('isFetching', false), targetModule = targetModule.set('shortcode_output', action.content);
            state = state.setIn(getInArray, targetModule);
            return state;

case 'SET_SPINNER':

var pathArray = getModuleKeyPath(action.path, '', ''),
                ajaxQueueLength,
                targetModule = state.getIn(pathArray);
            if (targetModule.has('isFetching') && targetModule.get('isFetching')) {
                ajaxQueueLength = targetModule.get('ajaxQueue');
                targetModule = targetModule.set('ajaxQueue', ajaxQueueLength + 1);
            } else {
                targetModule = targetModule.set('isFetching', true);
                targetModule = targetModule.set('ajaxQueue', 1);
            }
            state = state.setIn(pathArray, targetModule);
            return state;

case 'RESET_SPINNER':

var pathArray = getModuleKeyPath(action.path, '', ''),
                targetModule = state.getIn(pathArray),
                ajaxQueueLength = targetModule.get('ajaxQueue');
            if (1 == ajaxQueueLength) {
                targetModule = targetModule.delete('ajaxQueue');
                targetModule = targetModule.set('isFetching', false);
            } else {
                targetModule = targetModule.set('ajaxQueue', ajaxQueueLength - 1);
            }
            state = state.setIn(pathArray, targetModule);
            return state;

case 'UPDATE_SHORTCODE':

var getInArray = getModuleKeyPath(action.path, '', '');
            targetModule = state.getIn(getInArray), targetModule = targetModule.set('shortcode_output', action.shortcodeData);
            state = state.setIn(getInArray, targetModule);
            return state;

case 'DELETE_MODULE':

if (Immutable.List.isList(action.path.get(0))) {
                action.path.forEach(function (curPath) {

if (null == curPath) {
                        return;
                    }
                    var pathArray = getModuleKeyPath(curPath, '', ''),
                        moduleData = state.getIn(pathArray);

if ('tatsu_header_column' == moduleData.get('name') || 'tatsu_slide_menu_column' == moduleData.get('name') || 'tatsu_column' == moduleData.get('name') || 'tatsu_inner_column' == moduleData.get('name')) {
                        state = state.setIn(pathArray, moduleData.set('inner', Immutable.List()));
                    } else {
                        state = state.deleteIn(pathArray);
                    }
                });
                return state;
            } else {
                var pathArray = getModuleKeyPath(action.path, '', ''),
                    moduleData = state.getIn(pathArray);

if ('tatsu_header_column' == moduleData.get('name') || 'tatsu_slide_menu_column' == moduleData.get('name') || 'tatsu_column' == moduleData.get('name') || 'tatsu_inner_column' == moduleData.get('name')) {
                    state = state.setIn(pathArray, moduleData.set('inner', Immutable.List()));
                } else {
                    state = state.deleteIn(pathArray);
                }
                return state;
            }

case 'REORDER':

var sourceKeyPath = getModuleKeyPath(action.sourcePath, '', ''),
                targetKeyPath = getModuleKeyPath(action.targetPath, '', ''),
                targetLastIndex = targetKeyPath[targetKeyPath.length - 1],
                sourceLastIndex = sourceKeyPath[sourceKeyPath.length - 1],
                sourceModule = state.getIn(sourceKeyPath),
                targetModule = state.getIn(targetKeyPath);

if (action.sourcePath.size > action.targetPath.size) {
                targetKeyPath.push('inner');
                state = state.deleteIn(sourceKeyPath);
                state = state.setIn(targetKeyPath, state.getIn(targetKeyPath).insert(0, sourceModule));
            } else {

targetKeyPath.pop();
                state = state.deleteIn(sourceKeyPath);
                state = state.setIn(targetKeyPath, state.getIn(targetKeyPath).insert(targetLastIndex, sourceModule));
            }
            return state;

case 'COLUMNLAYOUT':

var keyPath = getModuleKeyPath(action.path, '', 'atts'),
                layoutsArray = action.layout.split("+"),
                currentColumns,
                index,
                gutterSpacing,
                gutter,
                newColumn,
                modifiedColumns = Immutable.List(),
                modifiedColumnsLastIndex,
                columnName;

keyPath.push('layout');
            state = state.setIn(keyPath, action.layout);
            keyPath = getModuleKeyPath(action.path, '', 'inner'), currentColumns = state.getIn(keyPath);
            layoutsArray.forEach(function (layout, index) {
                var newColumnDefn = new moduleObj();
                if (action.builderMode === 'header_builder') {
                    columnName = 'tatsu_header_column';
                } else {
                    if (2 == action.path.size) {
                        columnName = 'tatsu_column';
                    } else {
                        columnName = 'tatsu_inner_column';
                    }
                }
                newColumn = newColumnDefn.getModuleMap(columnName, action.moduleOptions);
                if ('undefined' != typeof currentColumns.get(index)) {
                    newColumn = newColumn.set('atts', currentColumns.getIn([index, 'atts']));
                    if (0 === index) {
                        gutterSpacing = currentColumns.getIn([index, 'atts', 'column_spacing']);
                        gutter = currentColumns.getIn([index, 'atts', 'gutter']);
                    }
                }

newColumn = newColumn.setIn(['atts', 'layout'], layout);
                if ('undefined' != typeof gutterSpacing && 'custom' === gutter && index >= currentColumns.size) {
                    newColumn = newColumn.setIn(['atts', 'column_spacing'], gutterSpacing);
                    newColumn = newColumn.setIn(['atts', 'gutter'], 'custom');
                }
                newColumn = newColumn.setIn(['atts', 'column_width'], Immutable.Map(getColumnWidth(layout, columnName)));
                modifiedColumns = modifiedColumns.push(newColumn);
            });
            modifiedColumnsLastIndex = modifiedColumns.size - 1;
            for (index = 0; index < currentColumns.size; index++) {
                if (index < modifiedColumns.size) {
                    modifiedColumns = modifiedColumns.setIn([index, 'inner'], currentColumns.getIn([index, 'inner']));
                } else {
                    modifiedColumns = modifiedColumns.setIn([modifiedColumnsLastIndex, 'inner'], modifiedColumns.getIn([modifiedColumnsLastIndex, 'inner']).concat(currentColumns.getIn([index, 'inner'])));
                }
            }

if (columnName === 'tatsu_header_column') {
                modifiedColumns = modifyAttsBeforeAddModule(modifiedColumns, 'tatsu_header_column', 'column_switch');
            }

state = state.setIn(keyPath, modifiedColumns);
            return state;

case 'DUPLICATE':

if (Immutable.List.isList(action.path.get(0))) {
                action.path.forEach(function (curPath) {

var pathArray = getModuleKeyPath(curPath, '', ''),
                        targetModule = state.getIn(pathArray),
                        duplicateModule;
                    if ('tatsu_column' == targetModule.get('name') || 'tatsu_inner_column' == targetModule.get('name')) {
                        return;
                    }
                    duplicateModule = changeUuid(targetModule);
                    pathArray.pop();
                    state = state.updateIn(pathArray, function (siblings) {

return siblings.insert(1 + curPath.last(), duplicateModule);
                    });
                });
            } else {
                var pathArray = getModuleKeyPath(action.path, '', ''),
                    targetModule = state.getIn(pathArray),
                    duplicateModule;
                if ('tatsu_column' == targetModule.get('name') || 'tatsu_inner_column' == targetModule.get('name')) {
                    return state;
                }
                duplicateModule = changeUuid(targetModule);
                pathArray.pop();
                state = state.updateIn(pathArray, function (siblings) {

return siblings.insert(1 + action.path.last(), duplicateModule);
                });
            }
            return state;

case 'ADD_MODULE':
            var newModule = addNewModule(action.moduleName, action.moduleOptions),
                pathArray = getModuleKeyPath(action.path, '', 'insert' == action.addType ? '' : 'inner'),
                parentComponentFinder = __webpack_require__(98),
                parentComponent = parentComponentFinder(action.path),
                insertIndex;

if (!action.moduleOptions.getIn([action.moduleName, 'is_built_in']) && 'sub_module' != action.moduleOptions.getIn([action.moduleName, 'type'])) {
                newModule = newModule.set('isFetching', true);
                newModule = newModule.set('ajaxQueue', 1);
            }

//Modify Atts
            if (newModule.get('name') === 'tatsu_header_row') {
                newModule = newModule.set('inner', modifyAttsBeforeAddModule(newModule.get('inner'), 'tatsu_header_column', 'new_module'));
            }
            if (parentComponent.get('name') === 'tatsu_hamburger_menu' || parentComponent.get('name') === 'tatsu_slide_menu_column') {
                newModule = modifyAttsBeforeAddModule(newModule, 'header_sidebar_module', 'new_module');
            }

if ('insert' == action.addType) {
                insertIndex = pathArray.pop();
                state = state.setIn(pathArray, state.getIn(pathArray).insert(insertIndex, newModule));
            } else {
                state = state.setIn(pathArray, state.getIn(pathArray).push(newModule));
            }
            return state;

case 'ADD_PASTED_MODULES':

var moduleList = action.moduleList,
                selectedModulePath = action.modulePath,
                builderMode = action.builderMode,
                pathArray = getModuleKeyPath(selectedModulePath, '', ''),
                selectedModule = state.getIn(pathArray),
                targetPath,
                targetPathArray,
                addType,
                targetInnerList,
                targetPosition;

moduleList.forEach(function (moduleData) {

targetPath = getTargetPastePath(selectedModulePath, selectedModule, moduleData, builderMode);
                if (Immutable.List.isList(targetPath)) {
                    targetPathArray = getModuleKeyPath(targetPath, '', '');
                    targetPosition = targetPathArray.pop() + 1;
                    targetInnerList = state.getIn(targetPathArray);
                    addType = targetPosition < targetInnerList.size - 1 ? 'insert' : 'push';
                    if ('insert' == addType) {
                        state = state.setIn(targetPathArray, targetInnerList.insert(targetPosition, moduleData));
                    } else {
                        state = state.setIn(targetPathArray, targetInnerList.push(moduleData));
                    }
                }
            });
            return state;

case 'EDIT_GLOBAL_SETTING':

state = state.setIn(['settings', action.settingKey], action.settingValue);

return state;

case 'LOAD_POST_REVISION':
            state = state.set('inner', action.data);
            return state;

default:
            return state;

}
}

function saveMonitor(state, action) {

var state = state || Immutable.List();
    switch (action.type) {
        case 'SET_CURRENT_SAVE_STATE':
            state = action.sectionList;
            return state;
        default:
            return state;

}
}

function moduleOptionsHolder(state, action) {

default:

return state;

}
}

function hoverHandler(state, action) {

var state = state || '';
    switch (action.type) {

case 'MESSAGE':

state = action.message;
            break;
        default:

return state;

}
}

function templateHandler(state, action) {

var state = state || Immutable.Map({
        prebuilt: Immutable.Map({
            sections: Immutable.List(),
            templates: Immutable.List()
        }),
        custom: Immutable.Map({
            sections: Immutable.List(),
            templates: Immutable.List()
        }),
        initialLoad: false
    });
    switch (action.type) {

case 'LOAD_TEMPLATE':

var templateMap = action.template;
            if (Immutable.Map.isMap(templateMap) && templateMap.has('prebuilt') && templateMap.has('custom')) {
                state = templateMap;
                state = state.set('initialLoad', true);
            }
            return state;

case 'DELETE_TEMPLATE':

case 'SAVE_AS_TEMPLATE':

var type = action.templateType,
                name = action.name,
                title = action.title,
                newTemplate;
            newTemplate = Immutable.Map({ name: name, title: title, created_at: action.createdAt, created_by: action.createdBy }), state = state.setIn(['custom', type, state.getIn(['custom', type]).size], newTemplate);
            return state;

case 'APPEND_TEMPLATE':
            var collection = action.collection,
                collectionType = action.collectionType;
            state = state.setIn(['prebuilt', collectionType], state.getIn(['prebuilt', collectionType]).concat(collection));
            return state;

default:
            return state;

}
}

function drawerController(state, action) {

var state = state || Immutable.Map({
        open: false,
        type: '',
        meta: Immutable.Map()
    });
    switch (action.type) {

case 'OPEN_DRAWER':
            state = state.set('open', true);
            state = state.set('type', action.currentDrawerType);
            state = state.set('meta', action.drawerMeta);
            return state;

case 'CLOSE_DRAWER':
            state = state.set('open', false);
            state = state.set('type', '');
            state = state.set('meta', Immutable.Map());
            return state;

default:
            return state;

}
}

function dragMonitor(state, action) {

var emptyStateMap = Immutable.Map({ isDragging: false, type: '', path: Immutable.List(), top: 0, left: 0, width: 0, name: '', position: '', dropEffect: 'move' }),
        state = state || emptyStateMap;
    switch (action.type) {

case 'BEGIN_DRAG':
            state = state.set('isDragging', true);
            state = state.set('type', action.dragType);
            return state;

case 'SET_DROP_EFFECT':
            state = state.set('dropEffect', action.dropEffect);
            return state;

case 'SET_DRAG_PLACEHOLDER':
            state = state.set('path', action.path);
            state = state.set('top', action.top);
            state = state.set('left', action.left);
            state = state.set('width', action.width);
            state = state.set('name', action.name);
            state = state.set('position', action.position);
            return state;

case 'RESET_DRAG_PLACEHOLDER':
            state = state.set('path', Immutable.List());
            state = state.set('top', 0);
            state = state.set('left', 0);
            state = state.set('width', 0);
            state = state.set('name', '');
            state = state.set('position', '');
            return state;

case 'END_DRAG':
            state = emptyStateMap;
            return state;

default:
            return state;

}
}

function responsiveController(state, action) {

var state = state || Immutable.Map({ targetDisplay: 'desktop' });

switch (action.type) {

case 'RESPONSIVE_SWITCH':
            state = state.set('targetDisplay', action.target);
            return state;

default:
            return state;

}
}

function messageBox(state, action) {

var state = state || Immutable.Map({ open: false, message: '', type: '', meta: Immutable.Map() });
    switch (action.type) {

case 'COMMUNICATE':
            if ('loader' === state.get('type') && true === state.get('open') && 'description' === action.messageType) {
                return state;
            }
            if ('popUp' == action.messageType) {
                state = state.set('open', true);
                state = state.set('type', action.messageType);
                state = state.set('meta', action.message);
                return state;
            }
            state = state.set('message', action.message);
            state = state.set('open', true);
            state = state.set('type', action.messageType);
            return state;

case 'CLOSE_SNACKBAR':
            if ('loader' === state.get('type') || 'popUp' == state.get('type')) {
                if (action.loadState) {
                    state = state.set('message', '');
                    state = state.set('open', false);
                }
            } else if ('popUp' == state.get('type')) {
                state = state.set('message', '');
                state = state.set('open', false);
            } else {
                state = state.set('message', '');
                state = state.set('open', false);
            }

return state;

default:
            return state;

}
}

function inlineController(state, action) {

var state = state || Immutable.Map({
        show: false,
        top: 0,
        left: 0,
        retrigger: false,
        override: false,
        url: false,
        alignment: false,
        colorPicker: false,
        listType: false,
        colorhubThings: false,
        font: false,
        activeEditorId: ''
    });
    switch (action.type) {

case 'REPOSITION_INLINE_TOOLBAR':
            if (!state.get('show')) {
                state = state.set('show', true);
                state = state.set('activeEditorId', action.activeEditorId);
                state = state.set('top', Number(action.currentTop));
                state = state.set('left', Number(action.currentLeft));
            } else {
                state = state.set('retrigger', true);
                state = state.set('top', Number(action.currentTop));
                state = state.set('left', Number(action.currentLeft));
            }
            return state;
        case 'RESET_INLINE_RETRIGGER':
            state = state.set('retrigger', false);
            return state;
        case 'SET_INLINE_EDITOR_ID':
            state = state.map(function (value, key) {

if ('activeEditorId' == key) {
                    return action.editorId;
                } else if ('top' == key || 'left' == key) {
                    return 0;
                } else {
                    return false;
                }
            });
            return state;
        case 'RESET_INLINE_TOOLBAR':
            state = state.map(function (value, key) {

if ('activeEditorId' == key) {
                    return '';
                } else if ('top' == key || 'left' == key) {
                    return 0;
                } else {
                    return false;
                }
            });
            return state;
        case 'TOGGLE_INLINE_OVERRIDE':
            state = state.set('override', action.override);
            return state;
        case 'TOGGLE_INLINE_TOOL':
            state = state.map(function (value, key) {

if (action.tool == key) {
                    return !value;
                } else {
                    return value;
                }
            });
            return state;
        default:
            return state;
    }
}

function contextMenuController(state, action) {

function selectionController(state, action) {

var initialState = Immutable.Map({
        type: '',
        multiType: '',
        selectionList: Immutable.List(),
        hide: false
    }),
        newSelection,
        state = state || initialState;
    switch (action.type) {
        case 'SET_SELECTION':

newSelection = Immutable.Map({
                path: action.path,
                top: action.top,
                left: action.left,
                title: action.title,
                name: action.name,
                id: action.id,
                dragHandle: action.dragHandle,
                builderType: action.builderType
            });
            if ('single' == action.selectionType) {
                state = state.set('type', 'single');
                state = state.set('multiType', '');
                state = state.set('selectionList', state.get('selectionList').clear().push(newSelection));
                return state;
            } else {
                if ('multi' != state.get('type')) {
                    if ('single' == state.get('type') && action.name != state.getIn(['selectionList', 0, 'name'])) {
                        state = state.set('multiType', 'miscellaneous');
                    } else {
                        state = state.set('multiType', 'similar');
                    }
                    if (!Immutable.is(action.path, state.getIn(['selectionList', 0, 'path']))) {
                        state = state.set('selectionList', state.get('selectionList').push(newSelection));
                    }
                    state = state.set('type', 'multi');
                } else {
                    var pathInSelectionState = getPathFromSelectionState(state);
                    if (pathInSelectionState.contains(action.path)) {
                        var deleteIndex = pathInSelectionState.findIndex(function (curPath) {

return Immutable.is(action.path, curPath);
                        });
                        state = state.deleteIn(['selectionList', deleteIndex]);
                        if (0 == state.get('selectionList').size) {
                            state = initialState;
                        } else if ('miscellaneous' == state.get('multiType')) {
                            var shouldChangeMultiType = state.get('selectionList').reduce(function (a, b) {

return true === a ? true : a.get('name') == b.get('name') ? a : true;
                            });
                            if (Immutable.Map.isMap(shouldChangeMultiType)) {
                                state = state.set('multiType', 'similar');
                            }
                        }
                    } else {
                        if ('similar' == state.get('multiType') && action.name != state.getIn(['selectionList', 0, 'name'])) {
                            state = state.set('multiType', 'miscellaneous');
                        }
                        state = state.set('selectionList', state.get('selectionList').push(newSelection));
                    }
                }
            }
            return state;

case 'HIDE_SELECTION':
            state = state.update('hide', function (curVisibility) {

return true;
            });
            return state;

case 'CHANGE_SELECTION_POSITION':

state = state.setIn(['selectionList', 0, 'top'], action.top);
            state = state.setIn(['selectionList', 0, 'left'], action.left);
            return state;

case 'SHOW_SELECTION':
            state = state.update('hide', function (curVisibility) {

return false;
            });
            return state;
        case 'RESET_SELECTION':
            state = initialState;
            return state;
        default:
            return state;
    }
}

function sectionPresetsHandler(state, action) {

var state = state || Immutable.List();
    switch (action.type) {

case 'LOAD_SECTION_PRESETS':
            state = action.presets;
            return state;

default:
            return state;

}
}

function headerRowPresetsHandler(state, action) {

var state = state || Immutable.List();
    switch (action.type) {

case 'LOAD_HEADER_ROW_PRESETS':
            state = action.presets;
            return state;

default:
            return state;

}
}

function sectionRenameController(state, action) {

var state = state || Immutable.Map({
        path: Immutable.List(),
        top: 0,
        left: 0,
        open: false,
        title: ''
    });
    switch (action.type) {

case 'SHOW_RENAME_TOOL':
            state = state.map(function (value, key) {

if ('open' == key) {
                    return true;
                } else {
                    return action[key];
                }
            });
            return state;

case 'HIDE_RENAME_TOOL':
            state = state.map(function (value, key) {

if ('open' == key) {
                    return false;
                } else if ('top' == key || 'left' == key) {
                    return 0;
                } else if ('title' == key) {
                    return '';
                } else {
                    return Immutable.List();
                }
            });
            return state;

default:
            return state;

}
}

function copyAtts(state, action) {

var initialState = Immutable.Map({
        name: '',
        atts: Immutable.OrderedMap()
    }),
        state = state || initialState;
    switch (action.type) {

case 'COPY_ATTS':
            var pathArray = getModuleKeyPath(action.path, '', 'atts'),
                atts = action.pageContent.getIn(pathArray),
                attsFromModuleOptions = action.moduleOptions.getIn([action.name, 'atts']);
            atts = atts.filter(function (attValue, attKey) {
                var attMap = attsFromModuleOptions.find(function (attMap) {
                    return Immutable.Map.isMap(attMap) && attMap.get('att_name') === attKey;
                });
                return Immutable.Map.isMap(attMap) && 'svg_icon_picker' != attMap.get('type') && 'icon_picker' != attMap.get('type') && 'text' != attMap.get('type') && 'text_area' != attMap.get('type') && 'tinymce' != attMap.get('type') && 'single_image_picker' != attMap.get('type');
            });
            state = state.set('name', action.name);
            state = state.set('atts', atts);
            return state;

default:
            return state;
    }
}

function revisionHelper(state, action) {

var initialState = {};

if (window.tatsuConfig.revision_data) {
        initialState = { backedUp: false, state: Immutable.List(), selectedRevision: '', revisionData: { revisions: window.tatsuConfig.revision_data.revisions, authors: window.tatsuConfig.revision_data.authors, more_items: window.tatsuConfig.revision_data.more_items }, revisionDataLoading: false };
    }

state = state || initialState;
    switch (action.type) {
        case 'BACKUP_CURRENT_STATE':
            return Object.assign({}, state, { backedUp: true, state: action.data });
        case 'CLEAR_REVISION_BACKUP':
            return Object.assign({}, state, { backedUp: false, state: Immutable.List(), selectedRevision: 'current' });
        case 'UPDATE_SELECTED_REVISION':
            return Object.assign({}, state, { selectedRevision: action.selectedRevision });
        case 'SET_LOADING_STATE':
            return Object.assign({}, state, { isLoading: action.isLoading });
        case 'UPDATE_REVISION_DATA':

var revisionData = {
                revisions: state.revisionData.revisions.concat(action.revisionData.revisions),
                authors: Object.assign({}, state.revisionData.authors, action.revisionData.authors),
                more_items: action.revisionData.more_items
            };

if (action.replace) {
                revisionData.revisions = action.revisionData.revisions;
            }

return Object.assign({}, state, { revisionData: revisionData });
        case 'REVISION_DATA_LOADING':
            return Object.assign({}, state, { revisionDataLoading: action.isLoading });
        default:
            return state;
    }
}

function modifyColWidth(state, pathArray, columnPath, attValue, targetDisplay) {

columnPath.pop();
    var totalColumns = state.getIn(columnPath).size,
        maxColIndex = totalColumns - 1,
        columns = state.getIn(columnPath),
        columnsWidth = [],
        sumOfColWidth,
        lowerLimit = 10,
        maxWidth = Math.round(100 / totalColumns * 100) / 100 * totalColumns,

//upperLimit = 1 == totalColumns ? 100 : ( ( ( Math.round( (100/totalColumns) * 100 )/100 ) * 2 )- 10 ),
    upperLimit = 1 == totalColumns ? 100 : 90,
        currentColumn = pathArray[pathArray.length - 1],
        //last value from path array is the column
    adjacentColumn = maxColIndex >= currentColumn + 1 ? currentColumn + 1 : currentColumn - 1,
        //column whose width will be adjusted
    widthAdjustment = false;

columns.map(function (thisColumn, index) {
        if (index !== currentColumn) {
            columnsWidth.push(parseFloat(thisColumn.getIn(['atts', 'column_width', targetDisplay.charAt('0')])));
        } else {
            attValue = parseFloat(attValue);
            columnsWidth.push(attValue >= lowerLimit ? attValue <= upperLimit ? attValue : upperLimit : lowerLimit);
        }
    });

sumOfColWidth = Math.round(columnsWidth.reduce(function (tempSum, val) {
        return tempSum + val;
    }) * 100) / 100;
    if (1 < totalColumns) {
        while (sumOfColWidth - maxWidth != 0) {
            var diff = sumOfColWidth - maxWidth,
                tempDiff;
            diff = parseFloat(diff.toFixed(2));
            if (!widthAdjustment) {
                tempDiff = Math.round((columnsWidth[adjacentColumn] - diff) * 100) / 100;
                columnsWidth[adjacentColumn] = tempDiff >= lowerLimit ? tempDiff <= upperLimit ? tempDiff : upperLimit : lowerLimit;
            } else {
                tempDiff = Math.round((columnsWidth[currentColumn] - diff) * 100) / 100;
                columnsWidth[currentColumn] = tempDiff >= lowerLimit ? tempDiff <= upperLimit ? tempDiff : upperLimit : lowerLimit;
            }
            widthAdjustment = true;
            sumOfColWidth = Math.round(columnsWidth.reduce(function (tempSum, val) {
                return tempSum + val;
            }) * 100) / 100;
        }
    }

return {
        columnsWidth: columnsWidth.map(function (value) {
            return parseFloat(value.toFixed(2));
        }),
        widthDiff: sumOfColWidth - maxWidth
    };
}

var mainReducer = combineReducers({

builderMode: setBuilderMode,
    tatsu_page_content: undoable(pageContent, {

limit: 20,
        debug: true,
        filter: filterActions

}),
    selectionController: selectionController,
    drawerController: drawerController,
    sectionPresetsController: sectionPresetsHandler,
    headerRowPresetsController: headerRowPresetsHandler,
    lastSavedState: saveMonitor,
    initialState: initialStateHandler,
    moduleOptions: moduleOptionsHolder,
    templateData: templateHandler,
    dragMonitor: dragMonitor,
    copyAtts: copyAtts,
    targetDisplay: responsiveController,
    sectionPresets: sectionPresetsHandler,
    headerRowPresets: headerRowPresetsHandler,
    messageBox: messageBox,
    inlineController: inlineController,
    contextMenuController: contextMenuController,
    revisionHelper: revisionHelper,
    globalPostDetails: globalPostDetails
});

module.exports = createStore(mainReducer, applyMiddleware(ReduxThunk));
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function (atts) {
    var visibilityClasses = ' ';
    if (Immutable.OrderedMap.isOrderedMap(atts) && '' !== atts.get('hide_in')) {
        visibilityClasses += atts.get('hide_in').split(',').map(function (deviceClass) {
            return 0 != deviceClass ? 'tatsu-hide-' + deviceClass : '';
        }).join(' ');
    }
    return visibilityClasses;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _setPrototypeOf = __webpack_require__(782);

var _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);

var _create = __webpack_require__(779);

var _create2 = _interopRequireDefault(_create);

var _typeof2 = __webpack_require__(161);

var _typeof3 = _interopRequireDefault(_typeof2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = function (subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : (0, _typeof3.default)(superClass)));
  }

subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass;
};

/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _typeof2 = __webpack_require__(161);

var _typeof3 = _interopRequireDefault(_typeof2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = function (self, call) {
  if (!self) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

return call && ((typeof call === "undefined" ? "undefined" : (0, _typeof3.default)(call)) === "object" || typeof call === "function") ? call : self;
};

/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports.listChecker = function (props, propName, componentName) {
	if (!Immutable.List.isList(props[propName])) {
		return new Error(props[propName] + ' must be a List! Kindly check the ' + componentName + ' component');
	}
};
module.exports.mapChecker = function (props, propName, componentName) {
	if (!Immutable.Map.isMap(props[propName])) {
		return new Error(props[propName] + ' must be a Map! Kindly check the ' + componentName + ' component');
	}
};
module.exports.orderedMapChecker = function (props, propName, componentName) {
	if (!Immutable.OrderedMap.isOrderedMap(props[propName])) {
		return new Error(props[propName] + ' must be a OrderedMap! kindly check ' + componentName + ' component');
	}
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ReactCSS = exports.loop = exports.handleActive = exports.handleHover = exports.hover = undefined;

var _flattenNames = __webpack_require__(1431);

var _flattenNames2 = _interopRequireDefault(_flattenNames);

var _mergeClasses = __webpack_require__(1433);

var _mergeClasses2 = _interopRequireDefault(_mergeClasses);

var _autoprefix = __webpack_require__(1428);

var _autoprefix2 = _interopRequireDefault(_autoprefix);

var _hover2 = __webpack_require__(1430);

var _hover3 = _interopRequireDefault(_hover2);

var _active = __webpack_require__(1429);

var _active2 = _interopRequireDefault(_active);

var _loop2 = __webpack_require__(1432);

var _loop3 = _interopRequireDefault(_loop2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.hover = _hover3.default;
exports.handleHover = _hover3.default;
exports.handleActive = _active2.default;
exports.loop = _loop3.default;
var ReactCSS = exports.ReactCSS = function ReactCSS(classes) {
  for (var _len = arguments.length, activations = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    activations[_key - 1] = arguments[_key];
  }

var activeNames = (0, _flattenNames2.default)(activations);
  var merged = (0, _mergeClasses2.default)(classes, activeNames);
  return (0, _autoprefix2.default)(merged);
};

exports.default = ReactCSS;

/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
 * Copyright (c) 2014-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

var emptyFunction = __webpack_require__(44);

/**
 * Similar to invariant but only logs a warning if the condition is not met.
 * This can be used to log issues in development environments in critical
 * paths. Removing the logging code for production environments will keep the
 * same logic and follow the same code paths.
 */

var warning = emptyFunction;

if (process.env.NODE_ENV !== 'production') {
  var printWarning = function printWarning(format) {
    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }

warning = function warning(condition, format) {
    if (format === undefined) {
      throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
    }

if (format.indexOf('Failed Composite propType: ') === 0) {
      return; // Ignore CompositeComponent proptype check.
    }

if (!condition) {
      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
        args[_key2 - 2] = arguments[_key2];
      }

printWarning.apply(undefined, [format].concat(args));
    }
  };
}

module.exports = warning;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

/**
 * Use invariant() to assert state which your program assumes to be true.
 *
 * Provide sprintf-style format (only %s is supported) and arguments
 * to provide information about what broke and what you were
 * expecting.
 *
 * The invariant message will be stripped in production, but the invariant
 * will remain to ensure logic does not differ in production.
 */

var validateFormat = function validateFormat(format) {};

if (process.env.NODE_ENV !== 'production') {
  validateFormat = function validateFormat(format) {
    if (format === undefined) {
      throw new Error('invariant requires an error message argument');
    }
  };
}

function invariant(condition, format, a, b, c, d, e, f) {
  validateFormat(format);

if (!condition) {
    var error;
    if (format === undefined) {
      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
    } else {
      var args = [a, b, c, d, e, f];
      var argIndex = 0;
      error = new Error(format.replace(/%s/g, function () {
        return args[argIndex++];
      }));
      error.name = 'Invariant Violation';
    }

error.framesToPop = 1; // we don't care about invariant's own frame
    throw error;
  }
}

module.exports = invariant;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _defineProperty = __webpack_require__(383);

var _defineProperty2 = _interopRequireDefault(_defineProperty);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      (0, _defineProperty2.default)(target, descriptor.key, descriptor);
    }
  }

return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();

/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule reactProdInvariant
 * 
 */

/**
 * WARNING: DO NOT manually require this module.
 * This is a replacement for `invariant(...)` used by the error code system
 * and will _only_ be required by the corresponding babel pass.
 * It always throws.
 */

function reactProdInvariant(code) {
  var argCount = arguments.length - 1;

var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;

for (var argIdx = 0; argIdx < argCount; argIdx++) {
    message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
  }

message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';

var error = new Error(message);
  error.name = 'Invariant Violation';
  error.framesToPop = 1; // we don't care about reactProdInvariant's own frame

throw error;
}

module.exports = reactProdInvariant;

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _defineProperty = __webpack_require__(383);

var _defineProperty2 = _interopRequireDefault(_defineProperty);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = function (obj, key, value) {
  if (key in obj) {
    (0, _defineProperty2.default)(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

return obj;
};

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

var invariant = function(condition, format, a, b, c, d, e, f) {
  if (process.env.NODE_ENV !== 'production') {
    if (format === undefined) {
      throw new Error('invariant requires an error message argument');
    }
  }

if (!condition) {
    var error;
    if (format === undefined) {
      error = new Error(
        'Minified exception occurred; use the non-minified dev environment ' +
        'for the full error message and additional helpful warnings.'
      );
    } else {
      var args = [a, b, c, d, e, f];
      var argIndex = 0;
      error = new Error(
        format.replace(/%s/g, function() { return args[argIndex++]; })
      );
      error.name = 'Invariant Violation';
    }

error.framesToPop = 1; // we don't care about invariant's own frame
    throw error;
  }
};

module.exports = invariant;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/

/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;

function toObject(val) {
	if (val === null || val === undefined) {
		throw new TypeError('Object.assign cannot be called with null or undefined');
	}

return Object(val);
}

function shouldUseNative() {
	try {
		if (!Object.assign) {
			return false;
		}

// Detect buggy property enumeration order in older V8 versions.

// https://bugs.chromium.org/p/v8/issues/detail?id=4118
		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
		test1[5] = 'de';
		if (Object.getOwnPropertyNames(test1)[0] === '5') {
			return false;
		}

// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test2 = {};
		for (var i = 0; i < 10; i++) {
			test2['_' + String.fromCharCode(i)] = i;
		}
		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
			return test2[n];
		});
		if (order2.join('') !== '0123456789') {
			return false;
		}

// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test3 = {};
		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
			test3[letter] = letter;
		});
		if (Object.keys(Object.assign({}, test3)).join('') !==
				'abcdefghijklmnopqrst') {
			return false;
		}

return true;
	} catch (err) {
		// We don't expect any of the above to throw, but better to be safe.
		return false;
	}
}

module.exports = shouldUseNative() ? Object.assign : function (target, source) {
	var from;
	var to = toObject(target);
	var symbols;

for (var s = 1; s < arguments.length; s++) {
		from = Object(arguments[s]);

for (var key in from) {
			if (hasOwnProperty.call(from, key)) {
				to[key] = from[key];
			}
		}

if (getOwnPropertySymbols) {
			symbols = getOwnPropertySymbols(from);
			for (var i = 0; i < symbols.length; i++) {
				if (propIsEnumerable.call(from, symbols[i])) {
					to[symbols[i]] = from[symbols[i]];
				}
			}
		}
	}

return to;
};

/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Alpha = __webpack_require__(1178);

Object.defineProperty(exports, 'Alpha', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Alpha).default;
  }
});

var _Checkboard = __webpack_require__(483);

Object.defineProperty(exports, 'Checkboard', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Checkboard).default;
  }
});

var _EditableInput = __webpack_require__(1179);

Object.defineProperty(exports, 'EditableInput', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_EditableInput).default;
  }
});

var _Hue = __webpack_require__(1180);

Object.defineProperty(exports, 'Hue', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Hue).default;
  }
});

var _Raised = __webpack_require__(1181);

Object.defineProperty(exports, 'Raised', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Raised).default;
  }
});

var _Saturation = __webpack_require__(1182);

Object.defineProperty(exports, 'Saturation', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Saturation).default;
  }
});

var _ColorWrap = __webpack_require__(484);

Object.defineProperty(exports, 'ColorWrap', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_ColorWrap).default;
  }
});

var _Swatch = __webpack_require__(1183);

Object.defineProperty(exports, 'Swatch', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Swatch).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _isImmutable = __webpack_require__(703);

Object.defineProperty(exports, 'isImmutable', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_isImmutable).default;
  }
});

var _validateValues = __webpack_require__(706);

Object.defineProperty(exports, 'validateValues', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_validateValues).default;
  }
});

var _converToGrid = __webpack_require__(696);

Object.defineProperty(exports, 'convertToGrid', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_converToGrid).default;
  }
});

var _getObjectType = __webpack_require__(366);

Object.defineProperty(exports, 'getObjectType', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_getObjectType).default;
  }
});

var _getValueAndUnit = __webpack_require__(700);

Object.defineProperty(exports, 'getValueAndUnit', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_getValueAndUnit).default;
  }
});

var _hasKeys = __webpack_require__(701);

Object.defineProperty(exports, 'hasKeys', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_hasKeys).default;
  }
});

var _isValidDataStructure = __webpack_require__(705);

Object.defineProperty(exports, 'isValidDataStructure', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_isValidDataStructure).default;
  }
});

var _isEmpty = __webpack_require__(702);

Object.defineProperty(exports, 'isEmpty', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_isEmpty).default;
  }
});

var _isShallowEqual = __webpack_require__(704);

Object.defineProperty(exports, 'isShallowEqual', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_isShallowEqual).default;
  }
});

var _debounce = __webpack_require__(698);

Object.defineProperty(exports, 'debounce', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_debounce).default;
  }
});

var _convertToBool = __webpack_require__(697);

Object.defineProperty(exports, 'convertToBool', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_convertToBool).default;
  }
});

var _getClassNames = __webpack_require__(699);

Object.defineProperty(exports, 'getClassNames', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_getClassNames).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ }),
/* 27 */
/***/ (function(module, exports) {

/**
 * Checks if `value` is classified as an `Array` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
 * @example
 *
 * _.isArray([1, 2, 3]);
 * // => true
 *
 * _.isArray(document.body.children);
 * // => false
 *
 * _.isArray('abc');
 * // => false
 *
 * _.isArray(_.noop);
 * // => false
 */
var isArray = Array.isArray;

module.exports = isArray;

/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
 * Copyright 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule ReactDOMComponentTree
 */

var _prodInvariant = __webpack_require__(21);

var DOMProperty = __webpack_require__(90);
var ReactDOMComponentFlags = __webpack_require__(524);

var invariant = __webpack_require__(19);

var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
var Flags = ReactDOMComponentFlags;

var internalInstanceKey = '__reactInternalInstance$' + Math.random().toString(36).slice(2);

/**
 * Drill down (through composites and empty components) until we get a host or
 * host text component.
 *
 * This is pretty polymorphic but unavoidable with the current structure we have
 * for `_renderedChildren`.
 */
function getRenderedHostOrTextFromComponent(component) {
  var rendered;
  while (rendered = component._renderedComponent) {
    component = rendered;
  }
  return component;
}

/**
 * Populate `_hostNode` on the rendered host/text component with the given
 * DOM node. The passed `inst` can be a composite.
 */
function precacheNode(inst, node) {
  var hostInst = getRenderedHostOrTextFromComponent(inst);
  hostInst._hostNode = node;
  node[internalInstanceKey] = hostInst;
}

function uncacheNode(inst) {
  var node = inst._hostNode;
  if (node) {
    delete node[internalInstanceKey];
    inst._hostNode = null;
  }
}

/**
 * Populate `_hostNode` on each child of `inst`, assuming that the children
 * match up with the DOM (element) children of `node`.
 *
 * We cache entire levels at once to avoid an n^2 problem where we access the
 * children of a node sequentially and have to walk from the start to our target
 * node every time.
 *
 * Since we update `_renderedChildren` and the actual DOM at (slightly)
 * different times, we could race here and see a newer `_renderedChildren` than
 * the DOM nodes we see. To avoid this, ReactMultiChild calls
 * `prepareToManageChildren` before we change `_renderedChildren`, at which
 * time the container's child nodes are always cached (until it unmounts).
 */
function precacheChildNodes(inst, node) {
  if (inst._flags & Flags.hasCachedChildNodes) {
    return;
  }
  var children = inst._renderedChildren;
  var childNode = node.firstChild;
  outer: for (var name in children) {
    if (!children.hasOwnProperty(name)) {
      continue;
    }
    var childInst = children[name];
    var childID = getRenderedHostOrTextFromComponent(childInst)._domID;
    if (childID === 0) {
      // We're currently unmounting this child in ReactMultiChild; skip it.
      continue;
    }
    // We assume the child nodes are in the same order as the child instances.
    for (; childNode !== null; childNode = childNode.nextSibling) {
      if (childNode.nodeType === 1 && childNode.getAttribute(ATTR_NAME) === String(childID) || childNode.nodeType === 8 && childNode.nodeValue === ' react-text: ' + childID + ' ' || childNode.nodeType === 8 && childNode.nodeValue === ' react-empty: ' + childID + ' ') {
        precacheNode(childInst, childNode);
        continue outer;
      }
    }
    // We reached the end of the DOM children without finding an ID match.
     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unable to find element with ID %s.', childID) : _prodInvariant('32', childID) : void 0;
  }
  inst._flags |= Flags.hasCachedChildNodes;
}

/**
 * Given a DOM node, return the closest ReactDOMComponent or
 * ReactDOMTextComponent instance ancestor.
 */
function getClosestInstanceFromNode(node) {
  if (node[internalInstanceKey]) {
    return node[internalInstanceKey];
  }

// Walk up the tree until we find an ancestor whose instance we have cached.
  var parents = [];
  while (!node[internalInstanceKey]) {
    parents.push(node);
    if (node.parentNode) {
      node = node.parentNode;
    } else {
      // Top of the tree. This node must not be part of a React tree (or is
      // unmounted, potentially).
      return null;
    }
  }

var closest;
  var inst;
  for (; node && (inst = node[internalInstanceKey]); node = parents.pop()) {
    closest = inst;
    if (parents.length) {
      precacheChildNodes(inst, node);
    }
  }

return closest;
}

/**
 * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
 * instance, or null if the node was not rendered by this React.
 */
function getInstanceFromNode(node) {
  var inst = getClosestInstanceFromNode(node);
  if (inst != null && inst._hostNode === node) {
    return inst;
  } else {
    return null;
  }
}

/**
 * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
 * DOM node.
 */
function getNodeFromInstance(inst) {
  // Without this first invariant, passing a non-DOM-component triggers the next
  // invariant for a missing parent, which is super confusing.
  !(inst._hostNode !== undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;

if (inst._hostNode) {
    return inst._hostNode;
  }

// Walk up the tree until we find an ancestor whose DOM node we have cached.
  var parents = [];
  while (!inst._hostNode) {
    parents.push(inst);
    !inst._hostParent ? process.env.NODE_ENV !== 'production' ? invariant(false, 'React DOM tree root should always have a node reference.') : _prodInvariant('34') : void 0;
    inst = inst._hostParent;
  }

// Now parents contains each ancestor that does *not* have a cached native
  // node, and `inst` is the deepest ancestor that does.
  for (; parents.length; inst = parents.pop()) {
    precacheChildNodes(inst, inst._hostNode);
  }

return inst._hostNode;
}

var ReactDOMComponentTree = {
  getClosestInstanceFromNode: getClosestInstanceFromNode,
  getInstanceFromNode: getInstanceFromNode,
  getNodeFromInstance: getNodeFromInstance,
  precacheChildNodes: precacheChildNodes,
  precacheNode: precacheNode,
  uncacheNode: uncacheNode
};

module.exports = ReactDOMComponentTree;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 29 */
/***/ (function(module, exports) {

var g;

// This works in non-strict mode
g = (function() {
	return this;
})();

try {
	// This works if eval is allowed (see CSP)
	g = g || Function("return this")() || (1,eval)("this");
} catch(e) {
	// This works if the window reference is available
	if(typeof window === "object")
		g = window;
}

// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

module.exports = g;

/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);

/**
 * Simple, lightweight module assisting with the detection and context of
 * Worker. Helps avoid circular dependencies and allows code to reason about
 * whether or not they are in a Worker, even if they never include the main
 * `ReactWorker` dependency.
 */
var ExecutionEnvironment = {

canUseDOM: canUseDOM,

canUseWorkers: typeof Worker !== 'undefined',

canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),

canUseViewport: canUseDOM && !!window.screen,

isInWorker: !canUseDOM // For now, this is true - might change in the future.

};

module.exports = ExecutionEnvironment;

/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.default = routerWarning;
exports._resetWarned = _resetWarned;

var _warning = __webpack_require__(1266);

var _warning2 = _interopRequireDefault(_warning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var warned = {};

function routerWarning(falseToWarn, message) {
  // Only issue deprecation warnings once.
  if (message.indexOf('deprecated') !== -1) {
    if (warned[message]) {
      return;
    }

warned[message] = true;
  }

message = '[react-router] ' + message;

for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
    args[_key - 2] = arguments[_key];
  }

_warning2.default.apply(undefined, [falseToWarn, message].concat(args));
}

function _resetWarned() {
  warned = {};
}

/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var repositionInlineToolbar = __webpack_require__(2).repositionInlineToolbar,
    resetRetrigger = __webpack_require__(2).resetRetriggerInlineToolbar,
    resetInlineToolbar = __webpack_require__(2).resetInlineToolbar,
    setActiveEditorId = __webpack_require__(2).setActiveEditorId,
    store = __webpack_require__(11),
    count = 0,
    pushContentFromInlineEditor = __webpack_require__(2).pushContentFromInlineEditor;
module.exports.getSelectionBoundry = function (top, left) {

if (activeEditorId) {
        var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
            currentEditor = tinymce.get(activeEditorId),
            selectedNode,
            details = {
            type: 'unstyled',
            style: {
                color: '',
                fontSize: '',
                fontFamily: '',
                textDecoration: '',
                letterSpacing: '',
                lineHeight: '',
                bold: false,
                italic: false,
                textAlign: ''
            },
            class: '',
            isBlockquote: false,
            listType: ''
        },
            getCurrentStyle,
            requiredStyleArray,
            requiredBlockArray,
            checkBlockType;
        if (null != currentEditor) {
            selectedNode = currentEditor.selection.getStart(), getCurrentStyle = function getCurrentStyle(node) {

var currentNodeColor, currentNodeFontSize, currentNodeLetterSpacing, currentNodeLineHeight, currentNodeTextAlign, currentNodeClass, currentNodeTextDecoration;
                if ('' == details.style.color) {
                    currentNodeColor = node.style.color;
                    if ('' != currentNodeColor && 'string' == typeof currentNodeColor) {
                        details.style.color = currentNodeColor;
                    }
                }
                if (false == details.style.bold) {
                    if ('strong' == node.tagName.toLowerCase()) {
                        details.style.bold = true;
                    }
                }
                if (false == details.style.italic) {
                    if ('em' == node.tagName.toLowerCase()) {
                        details.style.italic = true;
                    }
                }
                if ('' == details.style.fontSize) {
                    currentNodeFontSize = node.style.fontSize;
                    if ('string' == typeof currentNodeFontSize && '' != currentNodeFontSize) {
                        details.style.fontSize = currentNodeFontSize.replace(/\D+/, '');
                    }
                }
                if ('' == details.style.letterSpacing) {
                    currentNodeLetterSpacing = node.style.letterSpacing;
                    if ('string' == typeof currentNodeLetterSpacing && '' != currentNodeLetterSpacing) {
                        details.style.letterSpacing = currentNodeLetterSpacing.replace(/\D+/, '');
                    }
                }
                if ('' == details.style.lineHeight) {
                    currentNodeLineHeight = node.style.lineHeight;
                    if ('string' == typeof currentNodeLineHeight && '' != currentNodeLineHeight) {
                        details.style.lineHeight = currentNodeLineHeight.replace(/\D+/, '');
                    }
                }
                if ('' == details.style.textDecoration) {
                    currentNodeTextDecoration = node.style.textDecoration;
                    if ('string' == typeof currentNodeTextDecoration && '' != currentNodeTextDecoration) {
                        details.style.textDecoration = currentNodeTextDecoration;
                    }
                }
                if ('' == details.style.textAlign && 'span' != node.tagName.toLowerCase()) {
                    currentNodeTextAlign = node.style.textAlign;
                    if ('string' == typeof currentNodeTextAlign && '' != currentNodeTextAlign) {
                        details.style.textAlign = currentNodeTextAlign;
                    }
                }
                if ('' == details.class) {
                    currentNodeClass = node.className;
                    if ('string' == typeof currentNodeClass && '' != currentNodeClass) {
                        details.class = currentNodeClass;
                    }
                }
            }, checkBlockType = function checkBlockType(node) {

window.addEventListener('message', function (event) {
        var messageArray = event.data.toString().split(' '),
            eventType = messageArray[0],
            editorId = messageArray[1];
        switch (eventType) {
            case 'showToolbar':
                store.dispatch(repositionInlineToolbar(editorId, messageArray[2], messageArray[3]));
                break;

case 'hideToolbar':
                store.dispatch(resetInlineToolbar());
                break;
            case 'passiveToolbar':
                store.dispatch(setActiveEditorId(editorId));
                break;
            case 'pushToState':
                var path = Immutable.List(JSON.parse("[" + messageArray[2].replace(/-/g, ',') + "]"));
                store.dispatch(pushContentFromInlineEditor(path, editorId));
                break;
            default:
                return;
        }
    });
};
module.exports.getSelectionAndContainerWidth = function (activeEditorId) {

var iframe = document.getElementById('tatsu-preview'),
        iframeWindow = iframe.contentWindow,
        selectionAndContainerWidth = {},
        container = iframe.contentDocument.getElementById(activeEditorId);
    selectionAndContainerWidth.selectionWidth = iframeWindow.getSelection().getRangeAt(0).getBoundingClientRect().width;
    selectionAndContainerWidth.containerWidth = container.getBoundingClientRect().left + container.clientWidth;
    selectionAndContainerWidth.isCollapsed = iframeWindow.getSelection().isCollapsed;
    selectionAndContainerWidth.containerLeft = container.getBoundingClientRect().left;
    return selectionAndContainerWidth;
};
module.exports.getBookmark = function (activeEditorId) {

var currentEditor = document.getElementById('tatsu-preview').contentWindow.tinymce.get(activeEditorId);
    return currentEditor.selection.getBookmark(2, true);
};
module.exports.moveToBookmark = function (bookmark, activeEditorId) {

var currentEditor = document.getElementById('tatsu-preview').contentWindow.tinymce.get(activeEditorId);
    currentEditor.selection.moveToBookmark(bookmark);
};
module.exports.getNeededStyleValue = function (activeEditorId, style) {

var selection = document.getElementById('tatsu-preview').contentWindow.getSelection();
    if (0 < selection.rangeCount) {
        return selection.getRangeAt(0).getBoundingClientRect().left;
    } else {
        return 0;
    }
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function (url) {
  var url = url.indexOf("layoutManager") > -1 ? url.substr(0, url.indexOf("layoutManager")) : url.indexOf("moduleEditor") > -1 ? url.substr(0, url.indexOf("moduleEditor")) : url.indexOf("moduleList") > -1 ? url.substr(0, url.indexOf("moduleList")) : url.indexOf("globalSettings") > -1 ? url.substr(0, url.indexOf("globalSettings")) : url.indexOf("tatsuRevisions") > -1 ? url.substr(0, url.indexOf("tatsuRevisions")) : url,
      urlLastIndex = url.length - 1;
  if (url.lastIndexOf("/") !== urlLastIndex) {
    url = url + "/";
  }
  return url;
};

/***/ }),
/* 34 */
/***/ (function(module, exports) {

var core = module.exports = { version: '2.6.12' };
if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef

/***/ }),
/* 35 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(545);

/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }

var _DragDropContext = __webpack_require__(1223);

exports.DragDropContext = _interopRequire(_DragDropContext);

var _DragLayer = __webpack_require__(1224);

exports.DragLayer = _interopRequire(_DragLayer);

var _DragSource = __webpack_require__(1225);

exports.DragSource = _interopRequire(_DragSource);

var _DropTarget = __webpack_require__(1226);

exports.DropTarget = _interopRequire(_DropTarget);

/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var isEmpty = __webpack_require__(5);

module.exports = function (value) {
    if (!isEmpty(value)) {
        var matches = '';
        var i = 0;

while (value.includes('tatsu_dynamic_field')) {
            matches = value.match(/\[tatsu_dynamic_field data="(.*?)"]/);
            //matches = value.match(/\{{{(.*?)\/(.*?)\/(.*?)\}}}/);
            if (!isEmpty(matches)) {
                value = value.replace(matches[0], tatsuConfig.dynamic_values[matches[1]]);
                i++;
            }
        }
        if (i > 0) {
            return value;
        }

if (value.includes('acf/') || value.includes('wp/')) {
            value = tatsuConfig.dynamic_values[value];
        }
    }

return value;
};

/***/ }),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function getModuleKeyPath(path, arg1, arg2) {

/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.createMemoryHistory = exports.hashHistory = exports.browserHistory = exports.applyRouterMiddleware = exports.formatPattern = exports.useRouterHistory = exports.match = exports.routerShape = exports.locationShape = exports.PropTypes = exports.RoutingContext = exports.RouterContext = exports.createRoutes = exports.useRoutes = exports.RouteContext = exports.Lifecycle = exports.History = exports.Route = exports.Redirect = exports.IndexRoute = exports.IndexRedirect = exports.withRouter = exports.IndexLink = exports.Link = exports.Router = undefined;

var _RouteUtils = __webpack_require__(75);

Object.defineProperty(exports, 'createRoutes', {
  enumerable: true,
  get: function get() {
    return _RouteUtils.createRoutes;
  }
});

var _PropTypes2 = __webpack_require__(308);

Object.defineProperty(exports, 'locationShape', {
  enumerable: true,
  get: function get() {
    return _PropTypes2.locationShape;
  }
});
Object.defineProperty(exports, 'routerShape', {
  enumerable: true,
  get: function get() {
    return _PropTypes2.routerShape;
  }
});

var _PatternUtils = __webpack_require__(112);

Object.defineProperty(exports, 'formatPattern', {
  enumerable: true,
  get: function get() {
    return _PatternUtils.formatPattern;
  }
});

var _Router2 = __webpack_require__(1251);

var _Router3 = _interopRequireDefault(_Router2);

var _Link2 = __webpack_require__(493);

var _Link3 = _interopRequireDefault(_Link2);

var _IndexLink2 = __webpack_require__(1245);

var _IndexLink3 = _interopRequireDefault(_IndexLink2);

var _withRouter2 = __webpack_require__(1264);

var _withRouter3 = _interopRequireDefault(_withRouter2);

var _IndexRedirect2 = __webpack_require__(1246);

var _IndexRedirect3 = _interopRequireDefault(_IndexRedirect2);

var _IndexRoute2 = __webpack_require__(1247);

var _IndexRoute3 = _interopRequireDefault(_IndexRoute2);

var _Redirect2 = __webpack_require__(494);

var _Redirect3 = _interopRequireDefault(_Redirect2);

var _Route2 = __webpack_require__(1249);

var _Route3 = _interopRequireDefault(_Route2);

var _History2 = __webpack_require__(1244);

var _History3 = _interopRequireDefault(_History2);

var _Lifecycle2 = __webpack_require__(1248);

var _Lifecycle3 = _interopRequireDefault(_Lifecycle2);

var _RouteContext2 = __webpack_require__(1250);

var _RouteContext3 = _interopRequireDefault(_RouteContext2);

var _useRoutes2 = __webpack_require__(1263);

var _useRoutes3 = _interopRequireDefault(_useRoutes2);

var _RouterContext2 = __webpack_require__(187);

var _RouterContext3 = _interopRequireDefault(_RouterContext2);

var _RoutingContext2 = __webpack_require__(1252);

var _RoutingContext3 = _interopRequireDefault(_RoutingContext2);

var _PropTypes3 = _interopRequireDefault(_PropTypes2);

var _match2 = __webpack_require__(1261);

var _match3 = _interopRequireDefault(_match2);

var _useRouterHistory2 = __webpack_require__(499);

var _useRouterHistory3 = _interopRequireDefault(_useRouterHistory2);

var _applyRouterMiddleware2 = __webpack_require__(1254);

var _applyRouterMiddleware3 = _interopRequireDefault(_applyRouterMiddleware2);

var _browserHistory2 = __webpack_require__(1255);

var _browserHistory3 = _interopRequireDefault(_browserHistory2);

var _hashHistory2 = __webpack_require__(1259);

var _hashHistory3 = _interopRequireDefault(_hashHistory2);

var _createMemoryHistory2 = __webpack_require__(496);

var _createMemoryHistory3 = _interopRequireDefault(_createMemoryHistory2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.Router = _Router3.default; /* components */

exports.Link = _Link3.default;
exports.IndexLink = _IndexLink3.default;
exports.withRouter = _withRouter3.default;

/* components (configuration) */

exports.IndexRedirect = _IndexRedirect3.default;
exports.IndexRoute = _IndexRoute3.default;
exports.Redirect = _Redirect3.default;
exports.Route = _Route3.default;

/* mixins */

exports.History = _History3.default;
exports.Lifecycle = _Lifecycle3.default;
exports.RouteContext = _RouteContext3.default;

/* utils */

exports.useRoutes = _useRoutes3.default;
exports.RouterContext = _RouterContext3.default;
exports.RoutingContext = _RoutingContext3.default;
exports.PropTypes = _PropTypes3.default;
exports.match = _match3.default;
exports.useRouterHistory = _useRouterHistory3.default;
exports.applyRouterMiddleware = _applyRouterMiddleware3.default;

/* histories */

exports.browserHistory = _browserHistory3.default;
exports.hashHistory = _hashHistory3.default;
exports.createMemoryHistory = _createMemoryHistory3.default;

/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
 * Copyright 2016-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule ReactInstrumentation
 */

var debugTool = null;

if (process.env.NODE_ENV !== 'production') {
  var ReactDebugTool = __webpack_require__(1388);
  debugTool = ReactDebugTool;
}

module.exports = { debugTool: debugTool };
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var getAttFromDisplay = __webpack_require__(123);

module.exports = function (moduleName, attName, value, moduleOptions, display) {

return value;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports.decodePath = function decodePath(routePath) {
	if (typeof routePath === 'undefined') {
		return undefined;
	} else {
		return decodeURIComponent(routePath);
	}
};
module.exports.encodePath = function encodePath(routePath) {
	return encodeURIComponent(routePath);
};

/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */

function makeEmptyFunction(arg) {
  return function () {
    return arg;
  };
}

/**
 * This function accepts and discards inputs; it has no side effects. This is
 * primarily useful idiomatically for overridable function endpoints which
 * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
 */
var emptyFunction = function emptyFunction() {};

emptyFunction.thatReturns = makeEmptyFunction;
emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
emptyFunction.thatReturnsNull = makeEmptyFunction(null);
emptyFunction.thatReturnsThis = function () {
  return this;
};
emptyFunction.thatReturnsArgument = function (arg) {
  return arg;
};

module.exports = emptyFunction;

/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {

var freeGlobal = __webpack_require__(440);

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

module.exports = root;

/***/ }),
/* 46 */
/***/ (function(module, exports) {

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */
function isObject(value) {
  var type = typeof value;
  return value != null && (type == 'object' || type == 'function');
}

module.exports = isObject;

/***/ }),
/* 47 */
/***/ (function(module, exports) {

/**
 * Checks if `value` is object-like. A value is object-like if it's not `null`
 * and has a `typeof` result of "object".
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 * @example
 *
 * _.isObjectLike({});
 * // => true
 *
 * _.isObjectLike([1, 2, 3]);
 * // => true
 *
 * _.isObjectLike(_.noop);
 * // => false
 *
 * _.isObjectLike(null);
 * // => false
 */
function isObjectLike(value) {
  return value != null && typeof value == 'object';
}

module.exports = isObjectLike;

/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {

var baseGetTag = __webpack_require__(84),
    getPrototype = __webpack_require__(285),
    isObjectLike = __webpack_require__(47);

/** `Object#toString` result references. */
var objectTag = '[object Object]';

/** Used for built-in method references. */
var funcProto = Function.prototype,
    objectProto = Object.prototype;

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Used to infer the `Object` constructor. */
var objectCtorString = funcToString.call(Object);

/**
 * Checks if `value` is a plain object, that is, an object created by the
 * `Object` constructor or one with a `[[Prototype]]` of `null`.
 *
 * @static
 * @memberOf _
 * @since 0.8.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 * }
 *
 * _.isPlainObject(new Foo);
 * // => false
 *
 * _.isPlainObject([1, 2, 3]);
 * // => false
 *
 * _.isPlainObject({ 'x': 0, 'y': 0 });
 * // => true
 *
 * _.isPlainObject(Object.create(null));
 * // => true
 */
function isPlainObject(value) {
  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
    return false;
  }
  var proto = getPrototype(value);
  if (proto === null) {
    return true;
  }
  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
  return typeof Ctor == 'function' && Ctor instanceof Ctor &&
    funcToString.call(Ctor) == objectCtorString;
}

module.exports = isPlainObject;

/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.red = undefined;

var _each = __webpack_require__(1080);

var _each2 = _interopRequireDefault(_each);

var _tinycolor = __webpack_require__(553);

var _tinycolor2 = _interopRequireDefault(_tinycolor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = {
  simpleCheckForValidColor: function simpleCheckForValidColor(data) {
    var keysToCheck = ['r', 'g', 'b', 'a', 'h', 's', 'l', 'v'];
    var checked = 0;
    var passed = 0;
    (0, _each2.default)(keysToCheck, function (letter) {
      if (data[letter]) {
        checked += 1;
        if (!isNaN(data[letter])) {
          passed += 1;
        }
        if (letter === 's' || letter === 'l') {
          var percentPatt = /^\d+%$/;
          if (percentPatt.test(data[letter])) {
            passed += 1;
          }
        }
      }
    });
    return checked === passed ? data : false;
  },
  toState: function toState(data, oldHue) {
    var color = data.hex ? (0, _tinycolor2.default)(data.hex) : (0, _tinycolor2.default)(data);
    var hsl = color.toHsl();
    var hsv = color.toHsv();
    var rgb = color.toRgb();
    var hex = color.toHex();
    if (hsl.s === 0) {
      hsl.h = oldHue || 0;
      hsv.h = oldHue || 0;
    }
    var transparent = hex === '000000' && rgb.a === 0;

return {
      hsl: hsl,
      hex: transparent ? 'transparent' : '#' + hex,
      rgb: rgb,
      hsv: hsv,
      oldHue: data.h || oldHue || hsl.h,
      source: data.source
    };
  },
  isValidHex: function isValidHex(hex) {
    // disable hex4 and hex8
    var lh = String(hex).charAt(0) === '#' ? 1 : 0;
    return hex.length !== 4 + lh && hex.length < 7 + lh && (0, _tinycolor2.default)(hex).isValid();
  },
  getContrastingColor: function getContrastingColor(data) {
    if (!data) {
      return '#fff';
    }
    var col = this.toState(data);
    if (col.hex === 'transparent') {
      return 'rgba(0,0,0,0.4)';
    }
    var yiq = (col.rgb.r * 299 + col.rgb.g * 587 + col.rgb.b * 114) / 1000;
    return yiq >= 128 ? '#000' : '#fff';
  }
};
var red = exports.red = {
  hsl: { a: 1, h: 0, l: 0.5, s: 1 },
  hex: '#ff0000',
  rgb: { r: 255, g: 0, b: 0, a: 1 },
  hsv: { h: 0, s: 1, v: 1, a: 1 }
};

/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var ReactCurrentOwner = __webpack_require__(63);

var invariant = __webpack_require__(19);
var warning = __webpack_require__(18);

var canUseCollections =
// Array.from
typeof Array.from === 'function' &&
// Map
typeof Map === 'function' && isNative(Map) &&
// Map.prototype.keys
Map.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) &&
// Set
typeof Set === 'function' && isNative(Set) &&
// Set.prototype.keys
Set.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys);

var itemMap;
var rootIDSet;

var itemByKey;
var rootByKey;

if (canUseCollections) {
  itemMap = new Map();
  rootIDSet = new Set();
} else {
  itemByKey = {};
  rootByKey = {};
}

var unmountedIDs = [];

// Use non-numeric keys to prevent V8 performance issues:
// https://github.com/facebook/react/pull/7232
function getKeyFromID(id) {
  return '.' + id;
}
function getIDFromKey(key) {
  return parseInt(key.substr(1), 10);
}

function get(id) {
  if (canUseCollections) {
    return itemMap.get(id);
  } else {
    var key = getKeyFromID(id);
    return itemByKey[key];
  }
}

function remove(id) {
  if (canUseCollections) {
    itemMap['delete'](id);
  } else {
    var key = getKeyFromID(id);
    delete itemByKey[key];
  }
}

function create(id, element, parentID) {
  var item = {
    element: element,
    parentID: parentID,
    text: null,
    childIDs: [],
    isMounted: false,
    updateCount: 0
  };

if (canUseCollections) {
    itemMap.set(id, item);
  } else {
    var key = getKeyFromID(id);
    itemByKey[key] = item;
  }
}

function addRoot(id) {
  if (canUseCollections) {
    rootIDSet.add(id);
  } else {
    var key = getKeyFromID(id);
    rootByKey[key] = true;
  }
}

function removeRoot(id) {
  if (canUseCollections) {
    rootIDSet['delete'](id);
  } else {
    var key = getKeyFromID(id);
    delete rootByKey[key];
  }
}

function getRegisteredIDs() {
  if (canUseCollections) {
    return Array.from(itemMap.keys());
  } else {
    return Object.keys(itemByKey).map(getIDFromKey);
  }
}

function getRootIDs() {
  if (canUseCollections) {
    return Array.from(rootIDSet.keys());
  } else {
    return Object.keys(rootByKey).map(getIDFromKey);
  }
}

function purgeDeep(id) {
  var item = get(id);
  if (item) {
    var childIDs = item.childIDs;

remove(id);
    childIDs.forEach(purgeDeep);
  }
}

function describeComponentFrame(name, source, ownerName) {
  return '\n    in ' + name + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');
}

function describeID(id) {
  var name = ReactComponentTreeHook.getDisplayName(id);
  var element = ReactComponentTreeHook.getElement(id);
  var ownerID = ReactComponentTreeHook.getOwnerID(id);
  var ownerName;
  if (ownerID) {
    ownerName = ReactComponentTreeHook.getDisplayName(ownerID);
  }
  process.env.NODE_ENV !== 'production' ? warning(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id) : void 0;
  return describeComponentFrame(name, element && element._source, ownerName);
}

var ReactComponentTreeHook = {
  onSetChildren: function (id, nextChildIDs) {
    var item = get(id);
    item.childIDs = nextChildIDs;

for (var i = 0; i < nextChildIDs.length; i++) {
      var nextChildID = nextChildIDs[i];
      var nextChild = get(nextChildID);
      !nextChild ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('140') : void 0;
      !(nextChild.childIDs != null || typeof nextChild.element !== 'object' || nextChild.element == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : _prodInvariant('141') : void 0;
      !nextChild.isMounted ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('71') : void 0;
      if (nextChild.parentID == null) {
        nextChild.parentID = id;
        // TODO: This shouldn't be necessary but mounting a new root during in
        // componentWillMount currently causes not-yet-mounted components to
        // be purged from our tree data so their parent ID is missing.
      }
      !(nextChild.parentID === id) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : _prodInvariant('142', nextChildID, nextChild.parentID, id) : void 0;
    }
  },
  onBeforeMountComponent: function (id, element, parentID) {
    create(id, element, parentID);
  },
  onBeforeUpdateComponent: function (id, element) {
    var item = get(id);
    if (!item || !item.isMounted) {
      // We may end up here as a result of setState() in componentWillUnmount().
      // In this case, ignore the element.
      return;
    }
    item.element = element;
  },
  onMountComponent: function (id) {
    var item = get(id);
    item.isMounted = true;
    var isRoot = item.parentID === 0;
    if (isRoot) {
      addRoot(id);
    }
  },
  onUpdateComponent: function (id) {
    var item = get(id);
    if (!item || !item.isMounted) {
      // We may end up here as a result of setState() in componentWillUnmount().
      // In this case, ignore the element.
      return;
    }
    item.updateCount++;
  },
  onUnmountComponent: function (id) {
    var item = get(id);
    if (item) {
      // We need to check if it exists.
      // `item` might not exist if it is inside an error boundary, and a sibling
      // error boundary child threw while mounting. Then this instance never
      // got a chance to mount, but it still gets an unmounting event during
      // the error boundary cleanup.
      item.isMounted = false;
      var isRoot = item.parentID === 0;
      if (isRoot) {
        removeRoot(id);
      }
    }
    unmountedIDs.push(id);
  },
  purgeUnmountedComponents: function () {
    if (ReactComponentTreeHook._preventPurging) {
      // Should only be used for testing.
      return;
    }

for (var i = 0; i < unmountedIDs.length; i++) {
      var id = unmountedIDs[i];
      purgeDeep(id);
    }
    unmountedIDs.length = 0;
  },
  isMounted: function (id) {
    var item = get(id);
    return item ? item.isMounted : false;
  },
  getCurrentStackAddendum: function (topElement) {
    var info = '';
    if (topElement) {
      var type = topElement.type;
      var name = typeof type === 'function' ? type.displayName || type.name : type;
      var owner = topElement._owner;
      info += describeComponentFrame(name || 'Unknown', topElement._source, owner && owner.getName());
    }

var currentOwner = ReactCurrentOwner.current;
    var id = currentOwner && currentOwner._debugID;

info += ReactComponentTreeHook.getStackAddendumByID(id);
    return info;
  },
  getStackAddendumByID: function (id) {
    var info = '';
    while (id) {
      info += describeID(id);
      id = ReactComponentTreeHook.getParentID(id);
    }
    return info;
  },
  getChildIDs: function (id) {
    var item = get(id);
    return item ? item.childIDs : [];
  },
  getDisplayName: function (id) {
    var element = ReactComponentTreeHook.getElement(id);
    if (!element) {
      return null;
    }
    return getDisplayName(element);
  },
  getElement: function (id) {
    var item = get(id);
    return item ? item.element : null;
  },
  getOwnerID: function (id) {
    var element = ReactComponentTreeHook.getElement(id);
    if (!element || !element._owner) {
      return null;
    }
    return element._owner._debugID;
  },
  getParentID: function (id) {
    var item = get(id);
    return item ? item.parentID : null;
  },
  getSource: function (id) {
    var item = get(id);
    var element = item ? item.element : null;
    var source = element != null ? element._source : null;
    return source;
  },
  getText: function (id) {
    var element = ReactComponentTreeHook.getElement(id);
    if (typeof element === 'string') {
      return element;
    } else if (typeof element === 'number') {
      return '' + element;
    } else {
      return null;
    }
  },
  getUpdateCount: function (id) {
    var item = get(id);
    return item ? item.updateCount : 0;
  },

getRegisteredIDs: getRegisteredIDs,

getRootIDs: getRootIDs
};

module.exports = ReactComponentTreeHook;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
 * Copyright 2014-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule ReactElement
 */

var _assign = __webpack_require__(24);

var ReactCurrentOwner = __webpack_require__(63);

var warning = __webpack_require__(18);
var canDefineProperty = __webpack_require__(330);
var hasOwnProperty = Object.prototype.hasOwnProperty;

// The Symbol used to tag the ReactElement type. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;

var RESERVED_PROPS = {
  key: true,
  ref: true,
  __self: true,
  __source: true
};

var specialPropKeyWarningShown, specialPropRefWarningShown;

/**
 * Factory method to create a new React element. This no longer adheres to
 * the class pattern, so do not use new to call it. Also, no instanceof check
 * will work. Instead test $$typeof field against Symbol.for('react.element') to check
 * if something is a React Element.
 *
 * @param {*} type
 * @param {*} key
 * @param {string|object} ref
 * @param {*} self A *temporary* helper to detect places where `this` is
 * different from the `owner` when React.createElement is called, so that we
 * can warn. We want to get rid of owner and replace string `ref`s with arrow
 * functions, and as long as `this` and owner are the same, there will be no
 * change in behavior.
 * @param {*} source An annotation object (added by a transpiler or otherwise)
 * indicating filename, line number, and/or other information.
 * @param {*} owner
 * @param {*} props
 * @internal
 */
var ReactElement = function (type, key, ref, self, source, owner, props) {
  var element = {
    // This tag allow us to uniquely identify this as a React Element
    $$typeof: REACT_ELEMENT_TYPE,

// Built-in properties that belong on the element
    type: type,
    key: key,
    ref: ref,
    props: props,

// Record the component responsible for creating this element.
    _owner: owner
  };

if (process.env.NODE_ENV !== 'production') {
    // The validation flag is currently mutative. We put it on
    // an external backing store so that we can freeze the whole object.
    // This can be replaced with a WeakMap once they are implemented in
    // commonly used development environments.
    element._store = {};
    var shadowChildren = Array.isArray(props.children) ? props.children.slice(0) : props.children;

// To make comparing ReactElements easier for testing purposes, we make
    // the validation flag non-enumerable (where possible, which should
    // include every environment we run tests in), so the test framework
    // ignores it.
    if (canDefineProperty) {
      Object.defineProperty(element._store, 'validated', {
        configurable: false,
        enumerable: false,
        writable: true,
        value: false
      });
      // self and source are DEV only properties.
      Object.defineProperty(element, '_self', {
        configurable: false,
        enumerable: false,
        writable: false,
        value: self
      });
      Object.defineProperty(element, '_shadowChildren', {
        configurable: false,
        enumerable: false,
        writable: false,
        value: shadowChildren
      });
      // Two elements created in two different places should be considered
      // equal for testing purposes and therefore we hide it from enumeration.
      Object.defineProperty(element, '_source', {
        configurable: false,
        enumerable: false,
        writable: false,
        value: source
      });
    } else {
      element._store.validated = false;
      element._self = self;
      element._shadowChildren = shadowChildren;
      element._source = source;
    }
    if (Object.freeze) {
      Object.freeze(element.props);
      Object.freeze(element);
    }
  }

return element;
};

/**
 * Create and return a new ReactElement of the given type.
 * See https://facebook.github.io/react/docs/top-level-api.html#react.createelement
 */
ReactElement.createElement = function (type, config, children) {
  var propName;

// Reserved names are extracted
  var props = {};

var key = null;
  var ref = null;
  var self = null;
  var source = null;

if (config != null) {
    if (hasValidRef(config)) {
      ref = config.ref;
    }
    if (hasValidKey(config)) {
      key = '' + config.key;
    }

self = config.__self === undefined ? null : config.__self;
    source = config.__source === undefined ? null : config.__source;
    // Remaining properties are added to a new props object
    for (propName in config) {
      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
        props[propName] = config[propName];
      }
    }
  }

// Children can be more than one argument, and those are transferred onto
  // the newly allocated props object.
  var childrenLength = arguments.length - 2;
  if (childrenLength === 1) {
    props.children = children;
  } else if (childrenLength > 1) {
    var childArray = Array(childrenLength);
    for (var i = 0; i < childrenLength; i++) {
      childArray[i] = arguments[i + 2];
    }
    props.children = childArray;
  }

// Resolve default props
  if (type && type.defaultProps) {
    var defaultProps = type.defaultProps;
    for (propName in defaultProps) {
      if (props[propName] === undefined) {
        props[propName] = defaultProps[propName];
      }
    }
  }
  if (process.env.NODE_ENV !== 'production') {
    if (key || ref) {
      if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {
        var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
        if (key) {
          defineKeyPropWarningGetter(props, displayName);
        }
        if (ref) {
          defineRefPropWarningGetter(props, displayName);
        }
      }
    }
  }
  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
};

/**
 * Return a function that produces ReactElements of a given type.
 * See https://facebook.github.io/react/docs/top-level-api.html#react.createfactory
 */
ReactElement.createFactory = function (type) {
  var factory = ReactElement.createElement.bind(null, type);
  // Expose the type on the factory and the prototype so that it can be
  // easily accessed on elements. E.g. `<Foo />.type === Foo`.
  // This should not be named `constructor` since this may not be the function
  // that created the element, and it may not even be a constructor.
  // Legacy hook TODO: Warn if this is accessed
  factory.type = type;
  return factory;
};

ReactElement.cloneAndReplaceKey = function (oldElement, newKey) {
  var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);

return newElement;
};

/**
 * Clone and return a new ReactElement using element as the starting point.
 * See https://facebook.github.io/react/docs/top-level-api.html#react.cloneelement
 */
ReactElement.cloneElement = function (element, config, children) {
  var propName;

// Original props are copied
  var props = _assign({}, element.props);

// Reserved names are extracted
  var key = element.key;
  var ref = element.ref;
  // Self is preserved since the owner is preserved.
  var self = element._self;
  // Source is preserved since cloneElement is unlikely to be targeted by a
  // transpiler, and the original source is probably a better indicator of the
  // true owner.
  var source = element._source;

// Owner will be preserved, unless ref is overridden
  var owner = element._owner;

if (config != null) {
    if (hasValidRef(config)) {
      // Silently steal the ref from the parent.
      ref = config.ref;
      owner = ReactCurrentOwner.current;
    }
    if (hasValidKey(config)) {
      key = '' + config.key;
    }

// Remaining properties override existing props
    var defaultProps;
    if (element.type && element.type.defaultProps) {
      defaultProps = element.type.defaultProps;
    }
    for (propName in config) {
      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
        if (config[propName] === undefined && defaultProps !== undefined) {
          // Resolve default props
          props[propName] = defaultProps[propName];
        } else {
          props[propName] = config[propName];
        }
      }
    }
  }

return ReactElement(element.type, key, ref, self, source, owner, props);
};

/**
 * Verifies the object is a ReactElement.
 * See https://facebook.github.io/react/docs/top-level-api.html#react.isvalidelement
 * @param {?object} object
 * @return {boolean} True if `object` is a valid component.
 * @final
 */
ReactElement.isValidElement = function (object) {
  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
};

ReactElement.REACT_ELEMENT_TYPE = REACT_ELEMENT_TYPE;

module.exports = ReactElement;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 52 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

// Initial setting
__WEBPACK_IMPORTED_MODULE_6__ant_design_icons_react__["a" /* default */].add.apply(__WEBPACK_IMPORTED_MODULE_6__ant_design_icons_react__["a" /* default */], __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_toConsumableArray___default()(Object.keys(__WEBPACK_IMPORTED_MODULE_5__ant_design_icons_lib_dist__).map(function (key) {
    return __WEBPACK_IMPORTED_MODULE_5__ant_design_icons_lib_dist__[key];
})));
__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_10__twoTonePrimaryColor__["a" /* setTwoToneColor */])('#1890ff');
var defaultTheme = 'outlined';
var dangerousTheme = undefined;
var Icon = function Icon(props) {
    var _classNames;

var className = props.className,
        type = props.type,
        Component = props.component,
        viewBox = props.viewBox,
        spin = props.spin,
        children = props.children,
        theme = props.theme,
        twoToneColor = props.twoToneColor,
        restProps = __rest(props, ["className", "type", "component", "viewBox", "spin", "children", "theme", "twoToneColor"]);

__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util_warning__["a" /* default */])(Boolean(type || Component || children), 'Icon should have `type` prop or `component` prop or `children`.');
    var classString = __WEBPACK_IMPORTED_MODULE_4_classnames___default()((_classNames = {}, __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, 'anticon', true), __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, 'anticon-' + type, Boolean(type)), _classNames), className);
    var svgClassString = __WEBPACK_IMPORTED_MODULE_4_classnames___default()(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()({}, 'anticon-spin', !!spin || type === 'loading'));
    var innerNode = void 0;
    // component > children > type
    if (Component) {
        var innerSvgProps = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, __WEBPACK_IMPORTED_MODULE_8__utils__["a" /* svgBaseProps */], { className: svgClassString, viewBox: viewBox });
        if (!viewBox) {
            delete innerSvgProps.viewBox;
        }
        innerNode = __WEBPACK_IMPORTED_MODULE_3_react__["createElement"](
            Component,
            innerSvgProps,
            children
        );
    }
    if (children) {
        __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util_warning__["a" /* default */])(Boolean(viewBox) || __WEBPACK_IMPORTED_MODULE_3_react__["Children"].count(children) === 1 && __WEBPACK_IMPORTED_MODULE_3_react__["isValidElement"](children) && __WEBPACK_IMPORTED_MODULE_3_react__["Children"].only(children).type === 'use', 'Make sure that you provide correct `viewBox`' + ' prop (default `0 0 1024 1024`) to the icon.');
        var _innerSvgProps = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, __WEBPACK_IMPORTED_MODULE_8__utils__["a" /* svgBaseProps */], { className: svgClassString });
        innerNode = __WEBPACK_IMPORTED_MODULE_3_react__["createElement"](
            'svg',
            __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, _innerSvgProps, { viewBox: viewBox }),
            children
        );
    }
    if (typeof type === 'string') {
        var computedType = type;
        if (theme) {
            var themeInName = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils__["b" /* getThemeFromTypeName */])(type);
            __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util_warning__["a" /* default */])(!themeInName || theme === themeInName, 'The icon name \'' + type + '\' already specify a theme \'' + themeInName + '\',' + (' the \'theme\' prop \'' + theme + '\' will be ignored.'));
        }
        computedType = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils__["c" /* withThemeSuffix */])(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils__["d" /* removeTypeTheme */])(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils__["e" /* alias */])(type)), dangerousTheme || theme || defaultTheme);
        innerNode = __WEBPACK_IMPORTED_MODULE_3_react__["createElement"](__WEBPACK_IMPORTED_MODULE_6__ant_design_icons_react__["a" /* default */], { className: svgClassString, type: computedType, primaryColor: twoToneColor });
    }
    return __WEBPACK_IMPORTED_MODULE_3_react__["createElement"](
        'i',
        __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, restProps, { className: classString }),
        innerNode
    );
};
function unstable_ChangeThemeOfIconsDangerously(theme) {
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util_warning__["a" /* default */])(false, 'You are using the unstable method \'Icon.unstable_ChangeThemeOfAllIconsDangerously\', ' + ('make sure that all the icons with theme \'' + theme + '\' display correctly.'));
    dangerousTheme = theme;
}
function unstable_ChangeDefaultThemeOfIcons(theme) {
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util_warning__["a" /* default */])(false, 'You are using the unstable method \'Icon.unstable_ChangeDefaultThemeOfIcons\', ' + ('make sure that all the icons with theme \'' + theme + '\' display correctly.'));
    defaultTheme = theme;
}
Icon.createFromIconfontCN = __WEBPACK_IMPORTED_MODULE_7__IconFont__["a" /* default */];
Icon.getTwoToneColor = __WEBPACK_IMPORTED_MODULE_10__twoTonePrimaryColor__["b" /* getTwoToneColor */];
Icon.setTwoToneColor = __WEBPACK_IMPORTED_MODULE_10__twoTonePrimaryColor__["a" /* setTwoToneColor */];
/* harmony default export */ __webpack_exports__["default"] = (Icon);

/***/ }),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var getColorMappedToId = __webpack_require__(711),
    getAttFromDisplay = __webpack_require__(123);

module.exports = function (atts, display, attsFromModuleOptions) {
    var moduleOptionsList;
    return atts.map(function (attValue, attKey) {
        if (Immutable.Map.isMap(attValue)) {
            moduleOptionsList = attsFromModuleOptions.find(function (attMap) {
                return attMap.get('att_name') == attKey;
            });
            if (Immutable.Map.isMap(moduleOptionsList)) {
                if (moduleOptionsList.get('type') === 'color') {
                    attValue = getColorMappedToId(attValue);
                }

if (moduleOptionsList.has('responsive')) {
                    if (moduleOptionsList.get('responsive') === true) {
                        if (Immutable.Map.isMap(attValue)) {
                            return getAttFromDisplay(attValue, display);
                        } else {
                            return attValue;
                        }
                    } else {
                        return attValue;
                    }
                } else {
                    return attValue;
                }
            }
        }
        return attValue;
    });
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

exports.default = function (obj, keys) {
  var target = {};

for (var i in obj) {
    if (keys.indexOf(i) >= 0) continue;
    if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
    target[i] = obj[i];
  }

return target;
};

/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {

var store = __webpack_require__(255)('wks');
var uid = __webpack_require__(164);
var Symbol = __webpack_require__(70).Symbol;
var USE_SYMBOL = typeof Symbol == 'function';

var $exports = module.exports = function (name) {
  return store[name] || (store[name] =
    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
};

$exports.store = store;

/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
 * Copyright 2014-2015, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

var warning = function() {};

if (process.env.NODE_ENV !== 'production') {
  warning = function(condition, format, args) {
    var len = arguments.length;
    args = new Array(len > 2 ? len - 2 : 0);
    for (var key = 2; key < len; key++) {
      args[key - 2] = arguments[key];
    }
    if (format === undefined) {
      throw new Error(
        '`warning(condition, format, ...args)` requires a warning ' +
        'message argument'
      );
    }

if (format.length < 10 || (/^[s\W]*$/).test(format)) {
      throw new Error(
        'The warning format should be able to uniquely identify this ' +
        'warning. Please, use a more descriptive format than: ' + format
      );
    }

if (!condition) {
      var argIndex = 0;
      var message = 'Warning: ' +
        format.replace(/%s/g, function() {
          return args[argIndex++];
        });
      if (typeof console !== 'undefined') {
        console.error(message);
      }
      try {
        // This error was thrown as a convenience so that you can use this stack
        // to find the callsite that caused this warning to fire.
        throw new Error(message);
      } catch(x) {}
    }
  };
}

module.exports = warning;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 57 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21),
    _assign = __webpack_require__(24);

var CallbackQueue = __webpack_require__(520);
var PooledClass = __webpack_require__(76);
var ReactFeatureFlags = __webpack_require__(528);
var ReactReconciler = __webpack_require__(114);
var Transaction = __webpack_require__(148);

var invariant = __webpack_require__(19);

var dirtyComponents = [];
var updateBatchNumber = 0;
var asapCallbackQueue = CallbackQueue.getPooled();
var asapEnqueued = false;

var batchingStrategy = null;

function ensureInjected() {
  !(ReactUpdates.ReactReconcileTransaction && batchingStrategy) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must inject a reconcile transaction class and batching strategy') : _prodInvariant('123') : void 0;
}

var UPDATE_QUEUEING = {
  initialize: function () {
    this.callbackQueue.reset();
  },
  close: function () {
    this.callbackQueue.notifyAll();
  }
};

var TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];

function ReactUpdatesFlushTransaction() {
  this.reinitializeTransaction();
  this.dirtyComponentsLength = null;
  this.callbackQueue = CallbackQueue.getPooled();
  this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled(
  /* useCreateElement */true);
}

_assign(ReactUpdatesFlushTransaction.prototype, Transaction.Mixin, {
  getTransactionWrappers: function () {
    return TRANSACTION_WRAPPERS;
  },

destructor: function () {
    this.dirtyComponentsLength = null;
    CallbackQueue.release(this.callbackQueue);
    this.callbackQueue = null;
    ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);
    this.reconcileTransaction = null;
  },

perform: function (method, scope, a) {
    // Essentially calls `this.reconcileTransaction.perform(method, scope, a)`
    // with this transaction's wrappers around it.
    return Transaction.Mixin.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a);
  }
});

PooledClass.addPoolingTo(ReactUpdatesFlushTransaction);

function batchedUpdates(callback, a, b, c, d, e) {
  ensureInjected();
  batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
}

/**
 * Array comparator for ReactComponents by mount ordering.
 *
 * @param {ReactComponent} c1 first component you're comparing
 * @param {ReactComponent} c2 second component you're comparing
 * @return {number} Return value usable by Array.prototype.sort().
 */
function mountOrderComparator(c1, c2) {
  return c1._mountOrder - c2._mountOrder;
}

function runBatchedUpdates(transaction) {
  var len = transaction.dirtyComponentsLength;
  !(len === dirtyComponents.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected flush transaction\'s stored dirty-components length (%s) to match dirty-components array length (%s).', len, dirtyComponents.length) : _prodInvariant('124', len, dirtyComponents.length) : void 0;

// Since reconciling a component higher in the owner hierarchy usually (not
  // always -- see shouldComponentUpdate()) will reconcile children, reconcile
  // them before their children by sorting the array.
  dirtyComponents.sort(mountOrderComparator);

// Any updates enqueued while reconciling must be performed after this entire
  // batch. Otherwise, if dirtyComponents is [A, B] where A has children B and
  // C, B could update twice in a single batch if C's render enqueues an update
  // to B (since B would have already updated, we should skip it, and the only
  // way we can know to do so is by checking the batch counter).
  updateBatchNumber++;

for (var i = 0; i < len; i++) {
    // If a component is unmounted before pending changes apply, it will still
    // be here, but we assume that it has cleared its _pendingCallbacks and
    // that performUpdateIfNecessary is a noop.
    var component = dirtyComponents[i];

// If performUpdateIfNecessary happens to enqueue any new updates, we
    // shouldn't execute the callbacks until the next render happens, so
    // stash the callbacks first
    var callbacks = component._pendingCallbacks;
    component._pendingCallbacks = null;

var markerName;
    if (ReactFeatureFlags.logTopLevelRenders) {
      var namedComponent = component;
      // Duck type TopLevelWrapper. This is probably always true.
      if (component._currentElement.props === component._renderedComponent._currentElement) {
        namedComponent = component._renderedComponent;
      }
      markerName = 'React update: ' + namedComponent.getName();
      console.time(markerName);
    }

ReactReconciler.performUpdateIfNecessary(component, transaction.reconcileTransaction, updateBatchNumber);

if (markerName) {
      console.timeEnd(markerName);
    }

if (callbacks) {
      for (var j = 0; j < callbacks.length; j++) {
        transaction.callbackQueue.enqueue(callbacks[j], component.getPublicInstance());
      }
    }
  }
}

var flushBatchedUpdates = function () {
  // ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents
  // array and perform any updates enqueued by mount-ready handlers (i.e.,
  // componentDidUpdate) but we need to check here too in order to catch
  // updates enqueued by setState callbacks and asap calls.
  while (dirtyComponents.length || asapEnqueued) {
    if (dirtyComponents.length) {
      var transaction = ReactUpdatesFlushTransaction.getPooled();
      transaction.perform(runBatchedUpdates, null, transaction);
      ReactUpdatesFlushTransaction.release(transaction);
    }

if (asapEnqueued) {
      asapEnqueued = false;
      var queue = asapCallbackQueue;
      asapCallbackQueue = CallbackQueue.getPooled();
      queue.notifyAll();
      CallbackQueue.release(queue);
    }
  }
};

/**
 * Mark a component as needing a rerender, adding an optional callback to a
 * list of functions which will be executed once the rerender occurs.
 */
function enqueueUpdate(component) {
  ensureInjected();

// Various parts of our code (such as ReactCompositeComponent's
  // _renderValidatedComponent) assume that calls to render aren't nested;
  // verify that that's the case. (This is called by each top-level update
  // function, like setState, forceUpdate, etc.; creation and
  // destruction of top-level components is guarded in ReactMount.)

if (!batchingStrategy.isBatchingUpdates) {
    batchingStrategy.batchedUpdates(enqueueUpdate, component);
    return;
  }

dirtyComponents.push(component);
  if (component._updateBatchNumber == null) {
    component._updateBatchNumber = updateBatchNumber + 1;
  }
}

/**
 * Enqueue a callback to be run at the end of the current batching cycle. Throws
 * if no updates are currently being performed.
 */
function asap(callback, context) {
  !batchingStrategy.isBatchingUpdates ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates.asap: Can\'t enqueue an asap callback in a context whereupdates are not being batched.') : _prodInvariant('125') : void 0;
  asapCallbackQueue.enqueue(callback, context);
  asapEnqueued = true;
}

var ReactUpdatesInjection = {
  injectReconcileTransaction: function (ReconcileTransaction) {
    !ReconcileTransaction ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a reconcile transaction class') : _prodInvariant('126') : void 0;
    ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
  },

injectBatchingStrategy: function (_batchingStrategy) {
    !_batchingStrategy ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batching strategy') : _prodInvariant('127') : void 0;
    !(typeof _batchingStrategy.batchedUpdates === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batchedUpdates() function') : _prodInvariant('128') : void 0;
    !(typeof _batchingStrategy.isBatchingUpdates === 'boolean') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide an isBatchingUpdates boolean attribute') : _prodInvariant('129') : void 0;
    batchingStrategy = _batchingStrategy;
  }
};

var ReactUpdates = {
  /**
   * React references `ReactReconcileTransaction` using this property in order
   * to allow dependency injection.
   *
   * @internal
   */
  ReactReconcileTransaction: null,

batchedUpdates: batchedUpdates,
  enqueueUpdate: enqueueUpdate,
  flushBatchedUpdates: flushBatchedUpdates,
  injection: ReactUpdatesInjection,
  asap: asap
};

module.exports = ReactUpdates;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 58 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react_lifecycles_compat__ = __webpack_require__(61);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_tooltip__ = __webpack_require__(1161);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__config_provider__ = __webpack_require__(206);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__placements__ = __webpack_require__(627);

var Tooltip = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(Tooltip, _React$Component);

function Tooltip(props) {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, Tooltip);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Tooltip.__proto__ || Object.getPrototypeOf(Tooltip)).call(this, props));

_this.onVisibleChange = function (visible) {
            var onVisibleChange = _this.props.onVisibleChange;

if (!('visible' in _this.props)) {
                _this.setState({ visible: _this.isNoTitle() ? false : visible });
            }
            if (onVisibleChange && !_this.isNoTitle()) {
                onVisibleChange(visible);
            }
        };
        // 动态设置动画点
        _this.onPopupAlign = function (domNode, align) {
            var placements = _this.getPlacements();
            // 当前返回的位置
            var placement = Object.keys(placements).filter(function (key) {
                return placements[key].points[0] === align.points[0] && placements[key].points[1] === align.points[1];
            })[0];
            if (!placement) {
                return;
            }
            // 根据当前坐标设置动画点
            var rect = domNode.getBoundingClientRect();
            var transformOrigin = {
                top: '50%',
                left: '50%'
            };
            if (placement.indexOf('top') >= 0 || placement.indexOf('Bottom') >= 0) {
                transformOrigin.top = rect.height - align.offset[1] + 'px';
            } else if (placement.indexOf('Top') >= 0 || placement.indexOf('bottom') >= 0) {
                transformOrigin.top = -align.offset[1] + 'px';
            }
            if (placement.indexOf('left') >= 0 || placement.indexOf('Right') >= 0) {
                transformOrigin.left = rect.width - align.offset[0] + 'px';
            } else if (placement.indexOf('right') >= 0 || placement.indexOf('Left') >= 0) {
                transformOrigin.left = -align.offset[0] + 'px';
            }
            domNode.style.transformOrigin = transformOrigin.left + ' ' + transformOrigin.top;
        };
        _this.saveTooltip = function (node) {
            _this.tooltip = node;
        };
        _this.renderTooltip = function (_ref) {
            var getContextPopupContainer = _ref.getPopupContainer;
            var props = _this.props,
                state = _this.state;
            var prefixCls = props.prefixCls,
                title = props.title,
                overlay = props.overlay,
                openClassName = props.openClassName,
                getPopupContainer = props.getPopupContainer,
                getTooltipContainer = props.getTooltipContainer;

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(Tooltip, [{
        key: 'getPopupDomNode',
        value: function getPopupDomNode() {
            return this.tooltip.getPopupDomNode();
        }
    }, {
        key: 'getPlacements',
        value: function getPlacements() {
            var _props = this.props,
                builtinPlacements = _props.builtinPlacements,
                arrowPointAtCenter = _props.arrowPointAtCenter,
                autoAdjustOverflow = _props.autoAdjustOverflow;

return builtinPlacements || __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_11__placements__["a" /* default */])({
                arrowPointAtCenter: arrowPointAtCenter,
                verticalArrowShift: 8,
                autoAdjustOverflow: autoAdjustOverflow
            });
        }
        // Fix Tooltip won't hide at disabled button
        // mouse events don't trigger at disabled button in Chrome
        // https://github.com/react-component/tooltip/issues/18

}, {
        key: 'getDisabledCompatibleChildren',
        value: function getDisabledCompatibleChildren(element) {
            if ((element.type.__ANT_BUTTON || element.type === 'button') && element.props.disabled) {
                // Pick some layout related style properties up to span
                // Prevent layout bugs like https://github.com/ant-design/ant-design/issues/5254
                var _splitObject = splitObject(element.props.style, ['position', 'left', 'right', 'top', 'bottom', 'float', 'display', 'zIndex']),
                    picked = _splitObject.picked,
                    omitted = _splitObject.omitted;

return !title && !overlay; // overlay for old version compatibility
        }
    }, {
        key: 'render',
        value: function render() {
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                __WEBPACK_IMPORTED_MODULE_10__config_provider__["a" /* ConfigConsumer */],
                null,
                this.renderTooltip
            );
        }
    }], [{
        key: 'getDerivedStateFromProps',
        value: function getDerivedStateFromProps(nextProps) {
            if ('visible' in nextProps) {
                return { visible: nextProps.visible };
            }
            return null;
        }
    }]);

return Tooltip;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

Tooltip.defaultProps = {
    prefixCls: 'ant-tooltip',
    placement: 'top',
    transitionName: 'zoom-big-fast',
    mouseEnterDelay: 0.1,
    mouseLeaveDelay: 0.1,
    arrowPointAtCenter: false,
    autoAdjustOverflow: true
};
__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7_react_lifecycles_compat__["polyfill"])(Tooltip);
/* harmony default export */ __webpack_exports__["default"] = (Tooltip);

/***/ }),
/* 59 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(928);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);

/***/ }),
/* 60 */
/***/ (function(module, exports, __webpack_require__) {

var createFlow = __webpack_require__(1017);

/**
 * Creates a function that returns the result of invoking the given functions
 * with the `this` binding of the created function, where each successive
 * invocation is supplied the return value of the previous.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category Util
 * @param {...(Function|Function[])} [funcs] The functions to invoke.
 * @returns {Function} Returns the new composite function.
 * @see _.flowRight
 * @example
 *
 * function square(n) {
 *   return n * n;
 * }
 *
 * var addSquare = _.flow([_.add, square]);
 * addSquare(1, 2);
 * // => 9
 */
var flow = createFlow();

module.exports = flow;

/***/ }),
/* 61 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "polyfill", function() { return polyfill; });
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

function componentWillMount() {
  // Call this.constructor.gDSFP to support sub-classes.
  var state = this.constructor.getDerivedStateFromProps(this.props, this.state);
  if (state !== null && state !== undefined) {
    this.setState(state);
  }
}

function componentWillReceiveProps(nextProps) {
  // Call this.constructor.gDSFP to support sub-classes.
  // Use the setState() updater to ensure state isn't stale in certain edge cases.
  function updater(prevState) {
    var state = this.constructor.getDerivedStateFromProps(nextProps, prevState);
    return state !== null && state !== undefined ? state : null;
  }
  // Binding "this" is important for shallow renderer support.
  this.setState(updater.bind(this));
}

// React may warn about cWM/cWRP/cWU methods being deprecated.
// Add a flag to suppress these warnings for this special case.
componentWillMount.__suppressDeprecationWarning = true;
componentWillReceiveProps.__suppressDeprecationWarning = true;
componentWillUpdate.__suppressDeprecationWarning = true;

function polyfill(Component) {
  var prototype = Component.prototype;

if (!prototype || !prototype.isReactComponent) {
    throw new Error('Can only polyfill class components');
  }

if (
    typeof Component.getDerivedStateFromProps !== 'function' &&
    typeof prototype.getSnapshotBeforeUpdate !== 'function'
  ) {
    return Component;
  }

// If new component APIs are defined, "unsafe" lifecycles won't be called.
  // Error if any of these lifecycles are present,
  // Because they would work differently between older and newer (16.3+) versions of React.
  var foundWillMountName = null;
  var foundWillReceivePropsName = null;
  var foundWillUpdateName = null;
  if (typeof prototype.componentWillMount === 'function') {
    foundWillMountName = 'componentWillMount';
  } else if (typeof prototype.UNSAFE_componentWillMount === 'function') {
    foundWillMountName = 'UNSAFE_componentWillMount';
  }
  if (typeof prototype.componentWillReceiveProps === 'function') {
    foundWillReceivePropsName = 'componentWillReceiveProps';
  } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') {
    foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';
  }
  if (typeof prototype.componentWillUpdate === 'function') {
    foundWillUpdateName = 'componentWillUpdate';
  } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') {
    foundWillUpdateName = 'UNSAFE_componentWillUpdate';
  }
  if (
    foundWillMountName !== null ||
    foundWillReceivePropsName !== null ||
    foundWillUpdateName !== null
  ) {
    var componentName = Component.displayName || Component.name;
    var newApiName =
      typeof Component.getDerivedStateFromProps === 'function'
        ? 'getDerivedStateFromProps()'
        : 'getSnapshotBeforeUpdate()';

throw Error(
      'Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n' +
        componentName +
        ' uses ' +
        newApiName +
        ' but also contains the following legacy lifecycles:' +
        (foundWillMountName !== null ? '\n  ' + foundWillMountName : '') +
        (foundWillReceivePropsName !== null
          ? '\n  ' + foundWillReceivePropsName
          : '') +
        (foundWillUpdateName !== null ? '\n  ' + foundWillUpdateName : '') +
        '\n\nThe above lifecycles should be removed. Learn more about this warning here:\n' +
        'https://fb.me/react-async-component-lifecycle-hooks'
    );
  }

// React <= 16.2 does not support static getDerivedStateFromProps.
  // As a workaround, use cWM and cWRP to invoke the new static lifecycle.
  // Newer versions of React will ignore these lifecycles if gDSFP exists.
  if (typeof Component.getDerivedStateFromProps === 'function') {
    prototype.componentWillMount = componentWillMount;
    prototype.componentWillReceiveProps = componentWillReceiveProps;
  }

// React <= 16.2 does not support getSnapshotBeforeUpdate.
  // As a workaround, use cWU to invoke the new lifecycle.
  // Newer versions of React will ignore that lifecycle if gSBU exists.
  if (typeof prototype.getSnapshotBeforeUpdate === 'function') {
    if (typeof prototype.componentDidUpdate !== 'function') {
      throw new Error(
        'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype'
      );
    }

prototype.componentWillUpdate = componentWillUpdate;

var componentDidUpdate = prototype.componentDidUpdate;

prototype.componentDidUpdate = function componentDidUpdatePolyfill(
      prevProps,
      prevState,
      maybeSnapshot
    ) {
      // 16.3+ will not execute our will-update method;
      // It will pass a snapshot value to did-update though.
      // Older versions will require our polyfilled will-update value.
      // We need to handle both cases, but can't just check for the presence of "maybeSnapshot",
      // Because for <= 15.x versions this might be a "prevContext" object.
      // We also can't just check "__reactInternalSnapshot",
      // Because get-snapshot might return a falsy value.
      // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior.
      var snapshot = this.__reactInternalSnapshotFlag
        ? this.__reactInternalSnapshot
        : maybeSnapshot;

componentDidUpdate.call(this, prevProps, prevState, snapshot);
    };
  }

return Component;
}

/***/ }),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule EventConstants
 */

var keyMirror = __webpack_require__(167);

var PropagationPhases = keyMirror({ bubbled: null, captured: null });

/**
 * Types of raw signals from the browser caught at the top level.
 */
var topLevelTypes = keyMirror({
  topAbort: null,
  topAnimationEnd: null,
  topAnimationIteration: null,
  topAnimationStart: null,
  topBlur: null,
  topCanPlay: null,
  topCanPlayThrough: null,
  topChange: null,
  topClick: null,
  topCompositionEnd: null,
  topCompositionStart: null,
  topCompositionUpdate: null,
  topContextMenu: null,
  topCopy: null,
  topCut: null,
  topDoubleClick: null,
  topDrag: null,
  topDragEnd: null,
  topDragEnter: null,
  topDragExit: null,
  topDragLeave: null,
  topDragOver: null,
  topDragStart: null,
  topDrop: null,
  topDurationChange: null,
  topEmptied: null,
  topEncrypted: null,
  topEnded: null,
  topError: null,
  topFocus: null,
  topInput: null,
  topInvalid: null,
  topKeyDown: null,
  topKeyPress: null,
  topKeyUp: null,
  topLoad: null,
  topLoadedData: null,
  topLoadedMetadata: null,
  topLoadStart: null,
  topMouseDown: null,
  topMouseMove: null,
  topMouseOut: null,
  topMouseOver: null,
  topMouseUp: null,
  topPaste: null,
  topPause: null,
  topPlay: null,
  topPlaying: null,
  topProgress: null,
  topRateChange: null,
  topReset: null,
  topScroll: null,
  topSeeked: null,
  topSeeking: null,
  topSelectionChange: null,
  topStalled: null,
  topSubmit: null,
  topSuspend: null,
  topTextInput: null,
  topTimeUpdate: null,
  topTouchCancel: null,
  topTouchEnd: null,
  topTouchMove: null,
  topTouchStart: null,
  topTransitionEnd: null,
  topVolumeChange: null,
  topWaiting: null,
  topWheel: null
});

var EventConstants = {
  topLevelTypes: topLevelTypes,
  PropagationPhases: PropagationPhases
};

module.exports = EventConstants;

/***/ }),
/* 63 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * Keeps track of the current owner.
 *
 * The current owner is the component who should own any components that are
 * currently being constructed.
 */

var ReactCurrentOwner = {

/**
   * @internal
   * @type {ReactComponent}
   */
  current: null

};

module.exports = ReactCurrentOwner;

/***/ }),
/* 64 */
/***/ (function(module, exports, __webpack_require__) {

var _assign = __webpack_require__(24);

var PooledClass = __webpack_require__(76);

var emptyFunction = __webpack_require__(44);
var warning = __webpack_require__(18);

var didWarnForAddedNewProperty = false;
var isProxySupported = typeof Proxy === 'function';

var shouldBeReleasedProperties = ['dispatchConfig', '_targetInst', 'nativeEvent', 'isDefaultPrevented', 'isPropagationStopped', '_dispatchListeners', '_dispatchInstances'];

/**
 * @interface Event
 * @see http://www.w3.org/TR/DOM-Level-3-Events/
 */
var EventInterface = {
  type: null,
  target: null,
  // currentTarget is set when dispatching; no use in copying it here
  currentTarget: emptyFunction.thatReturnsNull,
  eventPhase: null,
  bubbles: null,
  cancelable: null,
  timeStamp: function (event) {
    return event.timeStamp || Date.now();
  },
  defaultPrevented: null,
  isTrusted: null
};

/**
 * Synthetic events are dispatched by event plugins, typically in response to a
 * top-level event delegation handler.
 *
 * These systems should generally use pooling to reduce the frequency of garbage
 * collection. The system should check `isPersistent` to determine whether the
 * event should be released into the pool after being dispatched. Users that
 * need a persisted event should invoke `persist`.
 *
 * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
 * normalizing browser quirks. Subclasses do not necessarily have to implement a
 * DOM interface; custom application-specific events can also subclass this.
 *
 * @param {object} dispatchConfig Configuration used to dispatch this event.
 * @param {*} targetInst Marker identifying the event target.
 * @param {object} nativeEvent Native browser event.
 * @param {DOMEventTarget} nativeEventTarget Target node.
 */
function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
  if (process.env.NODE_ENV !== 'production') {
    // these have a getter/setter for warnings
    delete this.nativeEvent;
    delete this.preventDefault;
    delete this.stopPropagation;
  }

this.dispatchConfig = dispatchConfig;
  this._targetInst = targetInst;
  this.nativeEvent = nativeEvent;

var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
  if (defaultPrevented) {
    this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
  } else {
    this.isDefaultPrevented = emptyFunction.thatReturnsFalse;
  }
  this.isPropagationStopped = emptyFunction.thatReturnsFalse;
  return this;
}

_assign(SyntheticEvent.prototype, {

preventDefault: function () {
    this.defaultPrevented = true;
    var event = this.nativeEvent;
    if (!event) {
      return;
    }

if (event.preventDefault) {
      event.preventDefault();
    } else if (typeof event.returnValue !== 'unknown') {
      // eslint-disable-line valid-typeof
      event.returnValue = false;
    }
    this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
  },

stopPropagation: function () {
    var event = this.nativeEvent;
    if (!event) {
      return;
    }

if (event.stopPropagation) {
      event.stopPropagation();
    } else if (typeof event.cancelBubble !== 'unknown') {
      // eslint-disable-line valid-typeof
      // The ChangeEventPlugin registers a "propertychange" event for
      // IE. This event does not support bubbling or cancelling, and
      // any references to cancelBubble throw "Member not found".  A
      // typeof check of "unknown" circumvents this issue (and is also
      // IE specific).
      event.cancelBubble = true;
    }

this.isPropagationStopped = emptyFunction.thatReturnsTrue;
  },

/**
   * We release all dispatched `SyntheticEvent`s after each event loop, adding
   * them back into the pool. This allows a way to hold onto a reference that
   * won't be added back into the pool.
   */
  persist: function () {
    this.isPersistent = emptyFunction.thatReturnsTrue;
  },

/**
   * Checks if this event should be released back into the pool.
   *
   * @return {boolean} True if this should not be released, false otherwise.
   */
  isPersistent: emptyFunction.thatReturnsFalse,

/**
   * `PooledClass` looks for `destructor` on each instance it releases.
   */
  destructor: function () {
    var Interface = this.constructor.Interface;
    for (var propName in Interface) {
      if (process.env.NODE_ENV !== 'production') {
        Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
      } else {
        this[propName] = null;
      }
    }
    for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
      this[shouldBeReleasedProperties[i]] = null;
    }
    if (process.env.NODE_ENV !== 'production') {
      Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
      Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));
      Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));
    }
  }

});

SyntheticEvent.Interface = EventInterface;

if (process.env.NODE_ENV !== 'production') {
  if (isProxySupported) {
    /*eslint-disable no-func-assign */
    SyntheticEvent = new Proxy(SyntheticEvent, {
      construct: function (target, args) {
        return this.apply(target, Object.create(target.prototype), args);
      },
      apply: function (constructor, that, args) {
        return new Proxy(constructor.apply(that, args), {
          set: function (target, prop, value) {
            if (prop !== 'isPersistent' && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {
              process.env.NODE_ENV !== 'production' ? warning(didWarnForAddedNewProperty || target.isPersistent(), 'This synthetic event is reused for performance reasons. If you\'re ' + 'seeing this, you\'re adding a new property in the synthetic event object. ' + 'The property is never released. See ' + 'https://fb.me/react-event-pooling for more information.') : void 0;
              didWarnForAddedNewProperty = true;
            }
            target[prop] = value;
            return true;
          }
        });
      }
    });
    /*eslint-enable no-func-assign */
  }
}
/**
 * Helper to reduce boilerplate when creating subclasses.
 *
 * @param {function} Class
 * @param {?object} Interface
 */
SyntheticEvent.augmentClass = function (Class, Interface) {
  var Super = this;

var E = function () {};
  E.prototype = Super.prototype;
  var prototype = new E();

_assign(prototype, Class.prototype);
  Class.prototype = prototype;
  Class.prototype.constructor = Class;

Class.Interface = _assign({}, Super.Interface, Interface);
  Class.augmentClass = Super.augmentClass;

PooledClass.addPoolingTo(Class, PooledClass.fourArgumentPooler);
};

PooledClass.addPoolingTo(SyntheticEvent, PooledClass.fourArgumentPooler);

module.exports = SyntheticEvent;

/**
  * Helper to nullify syntheticEvent instance properties when destructing
  *
  * @param {object} SyntheticEvent
  * @param {String} propName
  * @return {object} defineProperty object
  */
function getPooledWarningPropertyDefinition(propName, getVal) {
  var isFunction = typeof getVal === 'function';
  return {
    configurable: true,
    set: set,
    get: get
  };

function set(val) {
    var action = isFunction ? 'setting the method' : 'setting the property';
    warn(action, 'This is effectively a no-op');
    return val;
  }

function get() {
    var action = isFunction ? 'accessing the method' : 'accessing the property';
    var result = isFunction ? 'This is a no-op function' : 'This is set to null';
    warn(action, result);
    return getVal;
  }

function warn(action, result) {
    var warningCondition = false;
    process.env.NODE_ENV !== 'production' ? warning(warningCondition, 'This synthetic event is reused for performance reasons. If you\'re seeing this, ' + 'you\'re %s `%s` on a released/nullified synthetic event. %s. ' + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result) : void 0;
  }
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 65 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_select__ = __webpack_require__(473);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__locale_provider_LocaleReceiver__ = __webpack_require__(349);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__locale_provider_default__ = __webpack_require__(207);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__config_provider__ = __webpack_require__(206);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13_omit_js__ = __webpack_require__(138);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14_warning__ = __webpack_require__(117);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14_warning___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_14_warning__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_15__icon__ = __webpack_require__(52);

var SelectPropTypes = {
    prefixCls: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    className: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    size: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOf"](['default', 'large', 'small']),
    notFoundContent: __WEBPACK_IMPORTED_MODULE_7_prop_types__["any"],
    showSearch: __WEBPACK_IMPORTED_MODULE_7_prop_types__["bool"],
    optionLabelProp: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    transitionName: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    choiceTransitionName: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    id: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"]
};
// => It is needless to export the declaration of below two inner components.
// export { Option, OptGroup };

var Select = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Select, _React$Component);

function Select(props) {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Select);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Select.__proto__ || Object.getPrototypeOf(Select)).call(this, props));

_this.saveSelect = function (node) {
            _this.rcSelect = node;
        };
        _this.renderSelect = function (locale) {
            var _classNames;

var _a = _this.props,
                prefixCls = _a.prefixCls,
                _a$className = _a.className,
                className = _a$className === undefined ? '' : _a$className,
                size = _a.size,
                mode = _a.mode,
                getPopupContainer = _a.getPopupContainer,
                removeIcon = _a.removeIcon,
                clearIcon = _a.clearIcon,
                menuItemSelectedIcon = _a.menuItemSelectedIcon,
                restProps = __rest(_a, ["prefixCls", "className", "size", "mode", "getPopupContainer", "removeIcon", "clearIcon", "menuItemSelectedIcon"]);
            var rest = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13_omit_js__["a" /* default */])(restProps, ['inputIcon']);
            var cls = __WEBPACK_IMPORTED_MODULE_9_classnames___default()((_classNames = {}, __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-lg', size === 'large'), __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-sm', size === 'small'), _classNames), className);
            var optionLabelProp = _this.props.optionLabelProp;

if (_this.isCombobox()) {
                // children 带 dom 结构时，无法填入输入框
                optionLabelProp = optionLabelProp || 'value';
            }
            var modeConfig = {
                multiple: mode === 'multiple',
                tags: mode === 'tags',
                combobox: _this.isCombobox()
            };
            var finalRemoveIcon = removeIcon && (__WEBPACK_IMPORTED_MODULE_6_react__["isValidElement"](removeIcon) ? __WEBPACK_IMPORTED_MODULE_6_react__["cloneElement"](removeIcon, {
                className: __WEBPACK_IMPORTED_MODULE_9_classnames___default()(removeIcon.props.className, prefixCls + '-remove-icon')
            }) : removeIcon) || __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_15__icon__["default"], { type: 'close', className: prefixCls + '-remove-icon' });
            var finalClearIcon = clearIcon && (__WEBPACK_IMPORTED_MODULE_6_react__["isValidElement"](clearIcon) ? __WEBPACK_IMPORTED_MODULE_6_react__["cloneElement"](clearIcon, {
                className: __WEBPACK_IMPORTED_MODULE_9_classnames___default()(clearIcon.props.className, prefixCls + '-clear-icon')
            }) : clearIcon) || __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_15__icon__["default"], { type: 'close-circle', theme: 'filled', className: prefixCls + '-clear-icon' });
            var finalMenuItemSelectedIcon = menuItemSelectedIcon && (__WEBPACK_IMPORTED_MODULE_6_react__["isValidElement"](menuItemSelectedIcon) ? __WEBPACK_IMPORTED_MODULE_6_react__["cloneElement"](menuItemSelectedIcon, {
                className: __WEBPACK_IMPORTED_MODULE_9_classnames___default()(menuItemSelectedIcon.props.className, prefixCls + '-selected-icon')
            }) : menuItemSelectedIcon) || __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_15__icon__["default"], { type: 'check', className: prefixCls + '-selected-icon' });
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                __WEBPACK_IMPORTED_MODULE_12__config_provider__["a" /* ConfigConsumer */],
                null,
                function (_ref) {
                    var getContextPopupContainer = _ref.getPopupContainer;

return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_8_rc_select__["a" /* default */], __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ inputIcon: _this.renderSuffixIcon(), removeIcon: finalRemoveIcon, clearIcon: finalClearIcon, menuItemSelectedIcon: finalMenuItemSelectedIcon }, rest, modeConfig, { prefixCls: prefixCls, className: cls, optionLabelProp: optionLabelProp || 'children', notFoundContent: _this.getNotFoundContent(locale), getPopupContainer: getPopupContainer || getContextPopupContainer, ref: _this.saveSelect }));
                }
            );
        };
        __WEBPACK_IMPORTED_MODULE_14_warning___default()(props.mode !== 'combobox', 'The combobox mode of Select is deprecated,' + 'it will be removed in next major version,' + 'please use AutoComplete instead');
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Select, [{
        key: 'focus',
        value: function focus() {
            this.rcSelect.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.rcSelect.blur();
        }
    }, {
        key: 'getNotFoundContent',
        value: function getNotFoundContent(locale) {
            var notFoundContent = this.props.notFoundContent;

if (this.isCombobox()) {
                // AutoComplete don't have notFoundContent defaultly
                return notFoundContent === undefined ? null : notFoundContent;
            }
            return notFoundContent === undefined ? locale.notFoundContent : notFoundContent;
        }
    }, {
        key: 'isCombobox',
        value: function isCombobox() {
            var mode = this.props.mode;

return mode === 'combobox' || mode === Select.SECRET_COMBOBOX_MODE_DO_NOT_USE;
        }
    }, {
        key: 'renderSuffixIcon',
        value: function renderSuffixIcon() {
            var _props = this.props,
                prefixCls = _props.prefixCls,
                loading = _props.loading,
                suffixIcon = _props.suffixIcon;

if (suffixIcon) {
                return __WEBPACK_IMPORTED_MODULE_6_react__["isValidElement"](suffixIcon) ? __WEBPACK_IMPORTED_MODULE_6_react__["cloneElement"](suffixIcon, {
                    className: __WEBPACK_IMPORTED_MODULE_9_classnames___default()(suffixIcon.props.className, prefixCls + '-arrow-icon')
                }) : suffixIcon;
            }
            if (loading) {
                return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_15__icon__["default"], { type: 'loading' });
            }
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_15__icon__["default"], { type: 'down', className: prefixCls + '-arrow-icon' });
        }
    }, {
        key: 'render',
        value: function render() {
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                __WEBPACK_IMPORTED_MODULE_10__locale_provider_LocaleReceiver__["a" /* default */],
                { componentName: 'Select', defaultLocale: __WEBPACK_IMPORTED_MODULE_11__locale_provider_default__["a" /* default */].Select },
                this.renderSelect
            );
        }
    }]);

return Select;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["default"] = (Select);

Select.Option = __WEBPACK_IMPORTED_MODULE_8_rc_select__["b" /* Option */];
Select.OptGroup = __WEBPACK_IMPORTED_MODULE_8_rc_select__["c" /* OptGroup */];
Select.SECRET_COMBOBOX_MODE_DO_NOT_USE = 'SECRET_COMBOBOX_MODE_DO_NOT_USE';
Select.defaultProps = {
    prefixCls: 'ant-select',
    showSearch: false,
    transitionName: 'slide-up',
    choiceTransitionName: 'zoom'
};
Select.propTypes = SelectPropTypes;

/***/ }),
/* 66 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(925);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__input_style__ = __webpack_require__(78);

// style dependencies

/***/ }),
/* 67 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var camelCase = __webpack_require__(1074);

module.exports = function (cssObject) {

var finalCSS = { style: {}, class: {} },
        wrapperStyle,
        wrapperClass = '';

for (var selector in cssObject) {

finalCSS.style[selector] = {};
        finalCSS.class[selector] = '';
        wrapperStyle = cssObject[selector];
        wrapperClass = '';

Object.keys(wrapperStyle).map(function (key) {
            var value = wrapperStyle[key];
            if (value != '') {
                key = camelCase(key);
                finalCSS.style[selector][key] = value;
                // Add Class to support Gradient Text
                if (key == 'webkitBackgroundClip' || key == 'webkitTextFillColor') {
                    wrapperClass = 'tatsu-gradient-text';
                    delete finalCSS.style[selector][key];
                }
                // Add Class to support Gradient Border
                if (key == 'borderImageSlice') {
                    wrapperClass = wrapperClass + ' tatsu-gradient-border';
                    delete finalCSS.style[selector][key];
                }
            }
            if (wrapperClass != '') {
                finalCSS.class[selector] = wrapperClass;
            }
        });
    }
    return finalCSS;
};

/***/ }),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {

// Thank's IE8 for his funny defineProperty
module.exports = !__webpack_require__(101)(function () {
  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
});

/***/ }),
/* 69 */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(70);
var core = __webpack_require__(34);
var ctx = __webpack_require__(246);
var hide = __webpack_require__(102);
var has = __webpack_require__(81);
var PROTOTYPE = 'prototype';

/***/ }),
/* 70 */
/***/ (function(module, exports) {

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != 'undefined' && window.Math == Math
  ? window : typeof self != 'undefined' && self.Math == Math ? self
  // eslint-disable-next-line no-new-func
  : Function('return this')();
if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef

/***/ }),
/* 71 */
/***/ (function(module, exports, __webpack_require__) {

var anObject = __webpack_require__(100);
var IE8_DOM_DEFINE = __webpack_require__(389);
var toPrimitive = __webpack_require__(257);
var dP = Object.defineProperty;

exports.f = __webpack_require__(68) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
  anObject(O);
  P = toPrimitive(P, true);
  anObject(Attributes);
  if (IE8_DOM_DEFINE) try {
    return dP(O, P, Attributes);
  } catch (e) { /* empty */ }
  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
  if ('value' in Attributes) O[P] = Attributes.value;
  return O;
};

/***/ }),
/* 72 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

/**
 * Allows extraction of a minified key. Let's the build system minify keys
 * without losing the ability to dynamically use key strings as values
 * themselves. Pass in an object with a single key/val pair and it will return
 * you the string key of that single record. Suppose you want to grab the
 * value for a key 'className' inside of an object. Key/val minification may
 * have aliased that key to be 'xa12'. keyOf({className: null}) will return
 * 'xa12' in that case. Resolve keys you want to use once at startup time, then
 * reuse those resolutions.
 */
var keyOf = function keyOf(oneKeyObj) {
  var key;
  for (key in oneKeyObj) {
    if (!oneKeyObj.hasOwnProperty(key)) {
      continue;
    }
    return key;
  }
  return null;
};

module.exports = keyOf;

/***/ }),
/* 73 */
/***/ (function(module, exports, __webpack_require__) {

var isFunction = __webpack_require__(454),
    isLength = __webpack_require__(293);

/**
 * Checks if `value` is array-like. A value is considered array-like if it's
 * not a function and has a `value.length` that's an integer greater than or
 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
 * @example
 *
 * _.isArrayLike([1, 2, 3]);
 * // => true
 *
 * _.isArrayLike(document.body.children);
 * // => true
 *
 * _.isArrayLike('abc');
 * // => true
 *
 * _.isArrayLike(_.noop);
 * // => false
 */
function isArrayLike(value) {
  return value != null && isLength(value.length) && !isFunction(value);
}

module.exports = isArrayLike;

/***/ }),
/* 74 */
/***/ (function(module, exports, __webpack_require__) {

var arrayMap = __webpack_require__(107),
    baseIteratee = __webpack_require__(988),
    baseMap = __webpack_require__(990),
    isArray = __webpack_require__(27);

/**
 * Creates an array of values by running each element in `collection` thru
 * `iteratee`. The iteratee is invoked with three arguments:
 * (value, index|key, collection).
 *
 * Many lodash methods are guarded to work as iteratees for methods like
 * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
 *
 * The guarded methods are:
 * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
 * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
 * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
 * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Collection
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 * @example
 *
 * function square(n) {
 *   return n * n;
 * }
 *
 * _.map([4, 8], square);
 * // => [16, 64]
 *
 * _.map({ 'a': 4, 'b': 8 }, square);
 * // => [16, 64] (iteration order is not guaranteed)
 *
 * var users = [
 *   { 'user': 'barney' },
 *   { 'user': 'fred' }
 * ];
 *
 * // The `_.property` iteratee shorthand.
 * _.map(users, 'user');
 * // => ['barney', 'fred']
 */
function map(collection, iteratee) {
  var func = isArray(collection) ? arrayMap : baseMap;
  return func(collection, baseIteratee(iteratee, 3));
}

module.exports = map;

/***/ }),
/* 75 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

exports.isReactChildren = isReactChildren;
exports.createRouteFromReactElement = createRouteFromReactElement;
exports.createRoutesFromReactChildren = createRoutesFromReactChildren;
exports.createRoutes = createRoutes;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function isValidChild(object) {
  return object == null || _react2.default.isValidElement(object);
}

function isReactChildren(object) {
  return isValidChild(object) || Array.isArray(object) && object.every(isValidChild);
}

function createRoute(defaultProps, props) {
  return _extends({}, defaultProps, props);
}

function createRouteFromReactElement(element) {
  var type = element.type;
  var route = createRoute(type.defaultProps, element.props);

if (route.children) {
    var childRoutes = createRoutesFromReactChildren(route.children, route);

if (childRoutes.length) route.childRoutes = childRoutes;

delete route.children;
  }

return route;
}

/**
 * Creates and returns a routes object from the given ReactChildren. JSX
 * provides a convenient way to visualize how routes in the hierarchy are
 * nested.
 *
 *   import { Route, createRoutesFromReactChildren } from 'react-router'
 *
 *   const routes = createRoutesFromReactChildren(
 *     <Route component={App}>
 *       <Route path="home" component={Dashboard}/>
 *       <Route path="news" component={NewsFeed}/>
 *     </Route>
 *   )
 *
 * Note: This method is automatically used when you provide <Route> children
 * to a <Router> component.
 */
function createRoutesFromReactChildren(children, parentRoute) {
  var routes = [];

_react2.default.Children.forEach(children, function (element) {
    if (_react2.default.isValidElement(element)) {
      // Component classes may have a static create* method.
      if (element.type.createRouteFromReactElement) {
        var route = element.type.createRouteFromReactElement(element, parentRoute);

if (route) routes.push(route);
      } else {
        routes.push(createRouteFromReactElement(element));
      }
    }
  });

return routes;
}

/**
 * Creates and returns an array of routes from the given object which
 * may be a JSX route, a plain object route, or an array of either.
 */
function createRoutes(routes) {
  if (isReactChildren(routes)) {
    routes = createRoutesFromReactChildren(routes);
  } else if (routes && !Array.isArray(routes)) {
    routes = [routes];
  }

return routes;
}

/***/ }),
/* 76 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var invariant = __webpack_require__(19);

/**
 * Static poolers. Several custom versions for each potential number of
 * arguments. A completely generic pooler is easy to implement, but would
 * require accessing the `arguments` object. In each of these, `this` refers to
 * the Class itself, not an instance. If any others are needed, simply add them
 * here, or in their own files.
 */
var oneArgumentPooler = function (copyFieldsFrom) {
  var Klass = this;
  if (Klass.instancePool.length) {
    var instance = Klass.instancePool.pop();
    Klass.call(instance, copyFieldsFrom);
    return instance;
  } else {
    return new Klass(copyFieldsFrom);
  }
};

var standardReleaser = function (instance) {
  var Klass = this;
  !(instance instanceof Klass) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
  instance.destructor();
  if (Klass.instancePool.length < Klass.poolSize) {
    Klass.instancePool.push(instance);
  }
};

var DEFAULT_POOL_SIZE = 10;
var DEFAULT_POOLER = oneArgumentPooler;

/**
 * Augments `CopyConstructor` to be a poolable class, augmenting only the class
 * itself (statically) not adding any prototypical fields. Any CopyConstructor
 * you give this may have a `poolSize` property, and will look for a
 * prototypical `destructor` on instances.
 *
 * @param {Function} CopyConstructor Constructor that can be used to reset.
 * @param {Function} pooler Customizable pooler.
 */
var addPoolingTo = function (CopyConstructor, pooler) {
  var NewKlass = CopyConstructor;
  NewKlass.instancePool = [];
  NewKlass.getPooled = pooler || DEFAULT_POOLER;
  if (!NewKlass.poolSize) {
    NewKlass.poolSize = DEFAULT_POOL_SIZE;
  }
  NewKlass.release = standardReleaser;
  return NewKlass;
};

var PooledClass = {
  addPoolingTo: addPoolingTo,
  oneArgumentPooler: oneArgumentPooler,
  twoArgumentPooler: twoArgumentPooler,
  threeArgumentPooler: threeArgumentPooler,
  fourArgumentPooler: fourArgumentPooler,
  fiveArgumentPooler: fiveArgumentPooler
};

module.exports = PooledClass;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 77 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Input__ = __webpack_require__(348);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__Group__ = __webpack_require__(613);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__Search__ = __webpack_require__(614);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__TextArea__ = __webpack_require__(615);

__WEBPACK_IMPORTED_MODULE_0__Input__["a" /* default */].Group = __WEBPACK_IMPORTED_MODULE_1__Group__["a" /* default */];
__WEBPACK_IMPORTED_MODULE_0__Input__["a" /* default */].Search = __WEBPACK_IMPORTED_MODULE_2__Search__["a" /* default */];
__WEBPACK_IMPORTED_MODULE_0__Input__["a" /* default */].TextArea = __WEBPACK_IMPORTED_MODULE_3__TextArea__["a" /* default */];
/* harmony default export */ __webpack_exports__["default"] = (__WEBPACK_IMPORTED_MODULE_0__Input__["a" /* default */]);

/***/ }),
/* 78 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(921);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__button_style__ = __webpack_require__(203);

// style dependencies

/***/ }),
/* 79 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports.rowDnDConstant = {
  module: 'row'
};
module.exports.sortableDnDConstant = {
  module: 'sortable'
};
module.exports.moduleListDnDConstant = {
  module: 'moduleList'
};
module.exports.multiImageDnDConstant = {
  module: 'singleImageBlock'
};
module.exports.birdsEyeView = {
  module: 'birdseyeViewModule'
};

/***/ }),
/* 80 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

module.exports.addSelectedStyle = function (id) {

var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';

var idString = '.be-preview.be-pb-observer-' + id,

//existingStyle = document.getElementById( 'tatsu-preview' ).contentDocument.getElementById( 'tatsu-selected-style' ),
    style = document.createElement('style'),
        css,
        element,
        head = document.getElementById('tatsu-preview').contentDocument.getElementsByTagName('head')[0];
    css = idString + '{ border : 1px solid ' + primaryColor + '; position: relative; z-index:1; }';
    style.type = 'text/css';
    style.className = 'tatsu-selected-style style-' + id;
    // if( existingStyle ) {
    //     existingStyle.parentNode.removeChild( existingStyle );
    // }
    if (style.styleSheet) {
        style.styleSheet.cssText = css;
    } else {
        style.appendChild(document.createTextNode(css));
    }
    head.appendChild(style);
};

module.exports.removeSelectedStyle = function (id) {

if (null == id) {
        var targetStyles = document.getElementById('tatsu-preview').contentDocument.getElementsByClassName('tatsu-selected-style');
        [].forEach.call(targetStyles, function (element) {

element.parentNode.removeChild(element);
        });
    } else {
        var targetStyle = document.getElementById('tatsu-preview').contentDocument.querySelector('.tatsu-selected-style.style-' + id);
        if (targetStyle) {
            targetStyle.parentNode.removeChild(targetStyle);
        }
    }
    // var existingStyle = document.getElementById( 'tatsu-preview' ).contentDocument.getElementById( 'tatsu-selected-style' );
    // if( existingStyle ) {
    //     existingStyle.parentNode.removeChild( existingStyle );
    // }
};

module.exports.checkIfSelected = function (pathString, moduleType) {

/***/ }),
/* 81 */
/***/ (function(module, exports) {

var hasOwnProperty = {}.hasOwnProperty;
module.exports = function (it, key) {
  return hasOwnProperty.call(it, key);
};

/***/ }),
/* 82 */
/***/ (function(module, exports, __webpack_require__) {

// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = __webpack_require__(390);
var defined = __webpack_require__(247);
module.exports = function (it) {
  return IObject(defined(it));
};

/***/ }),
/* 83 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.extractPath = extractPath;
exports.parsePath = parsePath;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

function extractPath(string) {
  var match = string.match(/^https?:\/\/[^\/]*/);

if (match == null) return string;

return string.substring(match[0].length);
}

function parsePath(path) {
  var pathname = extractPath(path);
  var search = '';
  var hash = '';

process.env.NODE_ENV !== 'production' ? _warning2['default'](path === pathname, 'A path must be pathname + search + hash only, not a fully qualified URL like "%s"', path) : undefined;

var hashIndex = pathname.indexOf('#');
  if (hashIndex !== -1) {
    hash = pathname.substring(hashIndex);
    pathname = pathname.substring(0, hashIndex);
  }

var searchIndex = pathname.indexOf('?');
  if (searchIndex !== -1) {
    search = pathname.substring(searchIndex);
    pathname = pathname.substring(0, searchIndex);
  }

if (pathname === '') pathname = '/';

return {
    pathname: pathname,
    search: search,
    hash: hash
  };
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 84 */
/***/ (function(module, exports, __webpack_require__) {

var Symbol = __webpack_require__(106),
    getRawTag = __webpack_require__(1024),
    objectToString = __webpack_require__(1055);

/** `Object#toString` result references. */
var nullTag = '[object Null]',
    undefinedTag = '[object Undefined]';

/** Built-in value references. */
var symToStringTag = Symbol ? Symbol.toStringTag : undefined;

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
function baseGetTag(value) {
  if (value == null) {
    return value === undefined ? undefinedTag : nullTag;
  }
  return (symToStringTag && symToStringTag in Object(value))
    ? getRawTag(value)
    : objectToString(value);
}

module.exports = baseGetTag;

/***/ }),
/* 85 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsNative = __webpack_require__(985),
    getValue = __webpack_require__(1025);

/**
 * Gets the native function at `key` of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {string} key The key of the method to get.
 * @returns {*} Returns the function if it's native, else `undefined`.
 */
function getNative(object, key) {
  var value = getValue(object, key);
  return baseIsNative(value) ? value : undefined;
}

module.exports = getNative;

/***/ }),
/* 86 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsEqual = __webpack_require__(282);

/**
 * Performs a deep comparison between two values to determine if they are
 * equivalent.
 *
 * **Note:** This method supports comparing arrays, array buffers, booleans,
 * date objects, error objects, maps, numbers, `Object` objects, regexes,
 * sets, strings, symbols, and typed arrays. `Object` objects are compared
 * by their own, not inherited, enumerable properties. Functions and DOM
 * nodes are compared by strict equality, i.e. `===`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 *
 * var object = { 'a': 1 };
 * var other = { 'a': 1 };
 *
 * _.isEqual(object, other);
 * // => true
 *
 * object === other;
 * // => false
 */
function isEqual(value, other) {
  return baseIsEqual(value, other);
}

module.exports = isEqual;

/***/ }),
/* 87 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/**
 * @ignore
 * some key-codes definition and utils from closure-library
 * @author yiminghe@gmail.com
 */
var KeyCode = {
  /**
   * MAC_ENTER
   */
  MAC_ENTER: 3,

/**
   * BACKSPACE
   */
  BACKSPACE: 8,

/**
   * TAB
   */
  TAB: 9,

/**
   * NUMLOCK on FF/Safari Mac
   */
  NUM_CENTER: 12,

/**
   * ENTER
   */
  ENTER: 13,

/**
   * SHIFT
   */
  SHIFT: 16,

/**
   * CTRL
   */
  CTRL: 17,

/**
   * ALT
   */
  ALT: 18,

/**
   * PAUSE
   */
  PAUSE: 19,

/**
   * CAPS_LOCK
   */
  CAPS_LOCK: 20,

/**
   * ESC
   */
  ESC: 27,

/**
   * SPACE
   */
  SPACE: 32,

/**
   * PAGE_UP
   */
  PAGE_UP: 33,

/**
   * PAGE_DOWN
   */
  PAGE_DOWN: 34,

/**
   * END
   */
  END: 35,

/**
   * HOME
   */
  HOME: 36,

/**
   * LEFT
   */
  LEFT: 37,

/**
   * UP
   */
  UP: 38,

/**
   * RIGHT
   */
  RIGHT: 39,

/**
   * DOWN
   */
  DOWN: 40,

/**
   * PRINT_SCREEN
   */
  PRINT_SCREEN: 44,

/**
   * INSERT
   */
  INSERT: 45,

/**
   * DELETE
   */
  DELETE: 46,

/**
   * ZERO
   */
  ZERO: 48,

/**
   * ONE
   */
  ONE: 49,

/**
   * TWO
   */
  TWO: 50,

/**
   * THREE
   */
  THREE: 51,

/**
   * FOUR
   */
  FOUR: 52,

/**
   * FIVE
   */
  FIVE: 53,

/**
   * SIX
   */
  SIX: 54,

/**
   * SEVEN
   */
  SEVEN: 55,

/**
   * EIGHT
   */
  EIGHT: 56,

/**
   * NINE
   */
  NINE: 57,

/**
   * QUESTION_MARK
   */
  QUESTION_MARK: 63,

/**
   * A
   */
  A: 65,

/**
   * B
   */
  B: 66,

/**
   * C
   */
  C: 67,

/**
   * D
   */
  D: 68,

/**
   * E
   */
  E: 69,

/**
   * F
   */
  F: 70,

/**
   * G
   */
  G: 71,

/**
   * H
   */
  H: 72,

/**
   * I
   */
  I: 73,

/**
   * J
   */
  J: 74,

/**
   * K
   */
  K: 75,

/**
   * L
   */
  L: 76,

/**
   * M
   */
  M: 77,

/**
   * N
   */
  N: 78,

/**
   * O
   */
  O: 79,

/**
   * P
   */
  P: 80,

/**
   * Q
   */
  Q: 81,

/**
   * R
   */
  R: 82,

/**
   * S
   */
  S: 83,

/**
   * T
   */
  T: 84,

/**
   * U
   */
  U: 85,

/**
   * V
   */
  V: 86,

/**
   * W
   */
  W: 87,

/**
   * X
   */
  X: 88,

/**
   * Y
   */
  Y: 89,

/**
   * Z
   */
  Z: 90,

/**
   * META
   */
  META: 91,

/**
   * WIN_KEY_RIGHT
   */
  WIN_KEY_RIGHT: 92,

/**
   * CONTEXT_MENU
   */
  CONTEXT_MENU: 93,

/**
   * NUM_ZERO
   */
  NUM_ZERO: 96,

/**
   * NUM_ONE
   */
  NUM_ONE: 97,

/**
   * NUM_TWO
   */
  NUM_TWO: 98,

/**
   * NUM_THREE
   */
  NUM_THREE: 99,

/**
   * NUM_FOUR
   */
  NUM_FOUR: 100,

/**
   * NUM_FIVE
   */
  NUM_FIVE: 101,

/**
   * NUM_SIX
   */
  NUM_SIX: 102,

/**
   * NUM_SEVEN
   */
  NUM_SEVEN: 103,

/**
   * NUM_EIGHT
   */
  NUM_EIGHT: 104,

/**
   * NUM_NINE
   */
  NUM_NINE: 105,

/**
   * NUM_MULTIPLY
   */
  NUM_MULTIPLY: 106,

/**
   * NUM_PLUS
   */
  NUM_PLUS: 107,

/**
   * NUM_MINUS
   */
  NUM_MINUS: 109,

/**
   * NUM_PERIOD
   */
  NUM_PERIOD: 110,

/**
   * NUM_DIVISION
   */
  NUM_DIVISION: 111,

/**
   * F1
   */
  F1: 112,

/**
   * F2
   */
  F2: 113,

/**
   * F3
   */
  F3: 114,

/**
   * F4
   */
  F4: 115,

/**
   * F5
   */
  F5: 116,

/**
   * F6
   */
  F6: 117,

/**
   * F7
   */
  F7: 118,

/**
   * F8
   */
  F8: 119,

/**
   * F9
   */
  F9: 120,

/**
   * F10
   */
  F10: 121,

/**
   * F11
   */
  F11: 122,

/**
   * F12
   */
  F12: 123,

/**
   * NUMLOCK
   */
  NUMLOCK: 144,

/**
   * SEMICOLON
   */
  SEMICOLON: 186,

/**
   * DASH
   */
  DASH: 189,

/**
   * EQUALS
   */
  EQUALS: 187,

/**
   * COMMA
   */
  COMMA: 188,

/**
   * PERIOD
   */
  PERIOD: 190,

/**
   * SLASH
   */
  SLASH: 191,

/**
   * APOSTROPHE
   */
  APOSTROPHE: 192,

/**
   * SINGLE_QUOTE
   */
  SINGLE_QUOTE: 222,

/**
   * OPEN_SQUARE_BRACKET
   */
  OPEN_SQUARE_BRACKET: 219,

/**
   * BACKSLASH
   */
  BACKSLASH: 220,

/**
   * CLOSE_SQUARE_BRACKET
   */
  CLOSE_SQUARE_BRACKET: 221,

/**
   * WIN_KEY
   */
  WIN_KEY: 224,

/**
   * MAC_FF_META
   */
  MAC_FF_META: 224,

/**
   * WIN_IME
   */
  WIN_IME: 229,
  // ======================== Function ========================

/**
   * whether text and modified key is entered at the same time.
   */
  isTextModifyingKeyEvent: function isTextModifyingKeyEvent(e) {
    var keyCode = e.keyCode;

if (e.altKey && !e.ctrlKey || e.metaKey || // Function keys don't generate text
    keyCode >= KeyCode.F1 && keyCode <= KeyCode.F12) {
      return false;
    } // The following keys are quite harmless, even in combination with
    // CTRL, ALT or SHIFT.

switch (keyCode) {
      case KeyCode.ALT:
      case KeyCode.CAPS_LOCK:
      case KeyCode.CONTEXT_MENU:
      case KeyCode.CTRL:
      case KeyCode.DOWN:
      case KeyCode.END:
      case KeyCode.ESC:
      case KeyCode.HOME:
      case KeyCode.INSERT:
      case KeyCode.LEFT:
      case KeyCode.MAC_FF_META:
      case KeyCode.META:
      case KeyCode.NUMLOCK:
      case KeyCode.NUM_CENTER:
      case KeyCode.PAGE_DOWN:
      case KeyCode.PAGE_UP:
      case KeyCode.PAUSE:
      case KeyCode.PRINT_SCREEN:
      case KeyCode.RIGHT:
      case KeyCode.SHIFT:
      case KeyCode.UP:
      case KeyCode.WIN_KEY:
      case KeyCode.WIN_KEY_RIGHT:
        return false;

default:
        return true;
    }
  },

/**
   * whether character is entered.
   */
  isCharacterKey: function isCharacterKey(keyCode) {
    if (keyCode >= KeyCode.ZERO && keyCode <= KeyCode.NINE) {
      return true;
    }

if (keyCode >= KeyCode.NUM_ZERO && keyCode <= KeyCode.NUM_MULTIPLY) {
      return true;
    }

if (keyCode >= KeyCode.A && keyCode <= KeyCode.Z) {
      return true;
    } // Safari sends zero key code for non-latin characters.

if (window.navigator.userAgent.indexOf('WebKit') !== -1 && keyCode === 0) {
      return true;
    }

switch (keyCode) {
      case KeyCode.SPACE:
      case KeyCode.QUESTION_MARK:
      case KeyCode.NUM_PLUS:
      case KeyCode.NUM_MINUS:
      case KeyCode.NUM_PERIOD:
      case KeyCode.NUM_DIVISION:
      case KeyCode.SEMICOLON:
      case KeyCode.DASH:
      case KeyCode.EQUALS:
      case KeyCode.COMMA:
      case KeyCode.PERIOD:
      case KeyCode.SLASH:
      case KeyCode.APOSTROPHE:
      case KeyCode.SINGLE_QUOTE:
      case KeyCode.OPEN_SQUARE_BRACKET:
      case KeyCode.BACKSLASH:
      case KeyCode.CLOSE_SQUARE_BRACKET:
        return true;

default:
        return false;
    }
  }
};
/* harmony default export */ __webpack_exports__["a"] = (KeyCode);

/***/ }),
/* 88 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.routes = exports.route = exports.components = exports.component = exports.history = undefined;
exports.falsy = falsy;

var _react = __webpack_require__(0);

var func = _react.PropTypes.func;
var object = _react.PropTypes.object;
var arrayOf = _react.PropTypes.arrayOf;
var oneOfType = _react.PropTypes.oneOfType;
var element = _react.PropTypes.element;
var shape = _react.PropTypes.shape;
var string = _react.PropTypes.string;
function falsy(props, propName, componentName) {
  if (props[propName]) return new Error('<' + componentName + '> should not have a "' + propName + '" prop');
}

var history = exports.history = shape({
  listen: func.isRequired,
  push: func.isRequired,
  replace: func.isRequired,
  go: func.isRequired,
  goBack: func.isRequired,
  goForward: func.isRequired
});

var component = exports.component = oneOfType([func, string]);
var components = exports.components = oneOfType([component, object]);
var route = exports.route = oneOfType([object, element]);
var routes = exports.routes = oneOfType([route, arrayOf(route)]);

/***/ }),
/* 89 */
/***/ (function(module, exports) {

/**
 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(1);
 * // => false
 */
function isObject(value) {
  // Avoid a V8 JIT bug in Chrome 19-20.
  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
  var type = typeof value;
  return !!value && (type == 'object' || type == 'function');
}

module.exports = isObject;

/***/ }),
/* 90 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var invariant = __webpack_require__(19);

function checkMask(value, bitmask) {
  return (value & bitmask) === bitmask;
}

var DOMPropertyInjection = {
  /**
   * Mapping from normalized, camelcased property names to a configuration that
   * specifies how the associated DOM property should be accessed or rendered.
   */
  MUST_USE_PROPERTY: 0x1,
  HAS_BOOLEAN_VALUE: 0x4,
  HAS_NUMERIC_VALUE: 0x8,
  HAS_POSITIVE_NUMERIC_VALUE: 0x10 | 0x8,
  HAS_OVERLOADED_BOOLEAN_VALUE: 0x20,

/**
   * Inject some specialized knowledge about the DOM. This takes a config object
   * with the following properties:
   *
   * isCustomAttribute: function that given an attribute name will return true
   * if it can be inserted into the DOM verbatim. Useful for data-* or aria-*
   * attributes where it's impossible to enumerate all of the possible
   * attribute names,
   *
   * Properties: object mapping DOM property name to one of the
   * DOMPropertyInjection constants or null. If your attribute isn't in here,
   * it won't get written to the DOM.
   *
   * DOMAttributeNames: object mapping React attribute name to the DOM
   * attribute name. Attribute names not specified use the **lowercase**
   * normalized name.
   *
   * DOMAttributeNamespaces: object mapping React attribute name to the DOM
   * attribute namespace URL. (Attribute names not specified use no namespace.)
   *
   * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.
   * Property names not specified use the normalized name.
   *
   * DOMMutationMethods: Properties that require special mutation methods. If
   * `value` is undefined, the mutation method should unset the property.
   *
   * @param {object} domPropertyConfig the config as described above.
   */
  injectDOMPropertyConfig: function (domPropertyConfig) {
    var Injection = DOMPropertyInjection;
    var Properties = domPropertyConfig.Properties || {};
    var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {};
    var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};
    var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};
    var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};

if (domPropertyConfig.isCustomAttribute) {
      DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute);
    }

for (var propName in Properties) {
      !!DOMProperty.properties.hasOwnProperty(propName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'injectDOMPropertyConfig(...): You\'re trying to inject DOM property \'%s\' which has already been injected. You may be accidentally injecting the same DOM property config twice, or you may be injecting two configs that have conflicting property names.', propName) : _prodInvariant('48', propName) : void 0;

var lowerCased = propName.toLowerCase();
      var propConfig = Properties[propName];

var propertyInfo = {
        attributeName: lowerCased,
        attributeNamespace: null,
        propertyName: propName,
        mutationMethod: null,

mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY),
        hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE),
        hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE),
        hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE),
        hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE)
      };
      !(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s', propName) : _prodInvariant('50', propName) : void 0;

if (process.env.NODE_ENV !== 'production') {
        DOMProperty.getPossibleStandardName[lowerCased] = propName;
      }

if (DOMAttributeNames.hasOwnProperty(propName)) {
        var attributeName = DOMAttributeNames[propName];
        propertyInfo.attributeName = attributeName;
        if (process.env.NODE_ENV !== 'production') {
          DOMProperty.getPossibleStandardName[attributeName] = propName;
        }
      }

if (DOMAttributeNamespaces.hasOwnProperty(propName)) {
        propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName];
      }

if (DOMPropertyNames.hasOwnProperty(propName)) {
        propertyInfo.propertyName = DOMPropertyNames[propName];
      }

if (DOMMutationMethods.hasOwnProperty(propName)) {
        propertyInfo.mutationMethod = DOMMutationMethods[propName];
      }

DOMProperty.properties[propName] = propertyInfo;
    }
  }
};

/* eslint-disable max-len */
var ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
/* eslint-enable max-len */

/**
 * DOMProperty exports lookup objects that can be used like functions:
 *
 *   > DOMProperty.isValid['id']
 *   true
 *   > DOMProperty.isValid['foobar']
 *   undefined
 *
 * Although this may be confusing, it performs better in general.
 *
 * @see http://jsperf.com/key-exists
 * @see http://jsperf.com/key-missing
 */
var DOMProperty = {

ID_ATTRIBUTE_NAME: 'data-reactid',
  ROOT_ATTRIBUTE_NAME: 'data-reactroot',

ATTRIBUTE_NAME_START_CHAR: ATTRIBUTE_NAME_START_CHAR,
  ATTRIBUTE_NAME_CHAR: ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040',

/**
   * Map from property "standard name" to an object with info about how to set
   * the property in the DOM. Each object contains:
   *
   * attributeName:
   *   Used when rendering markup or with `*Attribute()`.
   * attributeNamespace
   * propertyName:
   *   Used on DOM node instances. (This includes properties that mutate due to
   *   external factors.)
   * mutationMethod:
   *   If non-null, used instead of the property or `setAttribute()` after
   *   initial render.
   * mustUseProperty:
   *   Whether the property must be accessed and mutated as an object property.
   * hasBooleanValue:
   *   Whether the property should be removed when set to a falsey value.
   * hasNumericValue:
   *   Whether the property must be numeric or parse as a numeric and should be
   *   removed when set to a falsey value.
   * hasPositiveNumericValue:
   *   Whether the property must be positive numeric or parse as a positive
   *   numeric and should be removed when set to a falsey value.
   * hasOverloadedBooleanValue:
   *   Whether the property can be used as a flag as well as with a value.
   *   Removed when strictly equal to false; present without a value when
   *   strictly equal to true; present with a value otherwise.
   */
  properties: {},

/**
   * Mapping from lowercase property names to the properly cased version, used
   * to warn in the case of missing properties. Available only in __DEV__.
   * @type {Object}
   */
  getPossibleStandardName: process.env.NODE_ENV !== 'production' ? {} : null,

/**
   * All of the isCustomAttribute() functions that have been injected.
   */
  _isCustomAttributeFunctions: [],

/**
   * Checks whether a property name is a custom attribute.
   * @method
   */
  isCustomAttribute: function (attributeName) {
    for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {
      var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];
      if (isCustomAttributeFn(attributeName)) {
        return true;
      }
    }
    return false;
  },

injection: DOMPropertyInjection
};

module.exports = DOMProperty;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 91 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rc_menu__ = __webpack_require__(140);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__config_provider__ = __webpack_require__(206);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__util_openAnimation__ = __webpack_require__(597);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__util_warning__ = __webpack_require__(202);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__SubMenu__ = __webpack_require__(618);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__MenuItem__ = __webpack_require__(617);

var Menu = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Menu, _React$Component);

function Menu(props) {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Menu);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Menu.__proto__ || Object.getPrototypeOf(Menu)).call(this, props));

_this.inlineOpenKeys = [];
        // Restore vertical mode when menu is collapsed responsively when mounted
        // https://github.com/ant-design/ant-design/issues/13104
        // TODO: not a perfect solution, looking a new way to avoid setting switchingModeFromInline in this situation
        _this.handleMouseEnter = function (e) {
            _this.restoreModeVerticalFromInline();
            var onMouseEnter = _this.props.onMouseEnter;

if (onMouseEnter) {
                onMouseEnter(e);
            }
        };
        _this.handleTransitionEnd = function (e) {
            // when inlineCollapsed menu width animation finished
            // https://github.com/ant-design/ant-design/issues/12864
            var widthCollapsed = e.propertyName === 'width' && e.target === e.currentTarget;
            // Fix for <Menu style={{ width: '100%' }} />, the width transition won't trigger when menu is collapsed
            // https://github.com/ant-design/ant-design-pro/issues/2783
            var iconScaled = e.propertyName === 'font-size' && e.target.className.indexOf('anticon') >= 0;
            if (widthCollapsed || iconScaled) {
                _this.restoreModeVerticalFromInline();
            }
        };
        _this.handleClick = function (e) {
            _this.handleOpenChange([]);
            var onClick = _this.props.onClick;

if (onClick) {
                onClick(e);
            }
        };
        _this.handleOpenChange = function (openKeys) {
            _this.setOpenKeys(openKeys);
            var onOpenChange = _this.props.onOpenChange;

if (onOpenChange) {
                onOpenChange(openKeys);
            }
        };
        _this.renderMenu = function (_ref) {
            var getPopupContainer = _ref.getPopupContainer;
            var _this$props = _this.props,
                prefixCls = _this$props.prefixCls,
                className = _this$props.className,
                theme = _this$props.theme;

if (_this.getInlineCollapsed() && (collapsedWidth === 0 || collapsedWidth === '0' || collapsedWidth === '0px')) {
                return null;
            }
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_7_rc_menu__["c" /* default */], __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ getPopupContainer: getPopupContainer }, _this.props, menuProps, { onTransitionEnd: _this.handleTransitionEnd, onMouseEnter: _this.handleMouseEnter }));
        };
        __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_12__util_warning__["a" /* default */])(!('onOpen' in props || 'onClose' in props), '`onOpen` and `onClose` are removed, please use `onOpenChange` instead, ' + 'see: https://u.ant.design/menu-on-open-change.');
        __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_12__util_warning__["a" /* default */])(!('inlineCollapsed' in props && props.mode !== 'inline'), "`inlineCollapsed` should only be used when Menu's `mode` is inline.");
        var openKeys = void 0;
        if ('openKeys' in props) {
            openKeys = props.openKeys;
        } else if ('defaultOpenKeys' in props) {
            openKeys = props.defaultOpenKeys;
        }
        _this.state = {
            openKeys: openKeys || []
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Menu, [{
        key: 'getChildContext',
        value: function getChildContext() {
            return {
                inlineCollapsed: this.getInlineCollapsed(),
                antdMenuTheme: this.props.theme
            };
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps, nextContext) {
            if (this.props.mode === 'inline' && nextProps.mode !== 'inline') {
                this.switchingModeFromInline = true;
            }
            if ('openKeys' in nextProps) {
                this.setState({ openKeys: nextProps.openKeys });
                return;
            }
            if (nextProps.inlineCollapsed && !this.props.inlineCollapsed || nextContext.siderCollapsed && !this.context.siderCollapsed) {
                this.switchingModeFromInline = true;
                this.inlineOpenKeys = this.state.openKeys;
                this.setState({ openKeys: [] });
            }
            if (!nextProps.inlineCollapsed && this.props.inlineCollapsed || !nextContext.siderCollapsed && this.context.siderCollapsed) {
                this.setState({ openKeys: this.inlineOpenKeys });
                this.inlineOpenKeys = [];
            }
        }
    }, {
        key: 'restoreModeVerticalFromInline',
        value: function restoreModeVerticalFromInline() {
            if (this.switchingModeFromInline) {
                this.switchingModeFromInline = false;
                this.setState({});
            }
        }
    }, {
        key: 'setOpenKeys',
        value: function setOpenKeys(openKeys) {
            if (!('openKeys' in this.props)) {
                this.setState({ openKeys: openKeys });
            }
        }
    }, {
        key: 'getRealMenuMode',
        value: function getRealMenuMode() {
            var inlineCollapsed = this.getInlineCollapsed();
            if (this.switchingModeFromInline && inlineCollapsed) {
                return 'inline';
            }
            var mode = this.props.mode;

return inlineCollapsed ? 'vertical' : mode;
        }
    }, {
        key: 'getInlineCollapsed',
        value: function getInlineCollapsed() {
            var inlineCollapsed = this.props.inlineCollapsed;

if (this.context.siderCollapsed !== undefined) {
                return this.context.siderCollapsed;
            }
            return inlineCollapsed;
        }
    }, {
        key: 'getMenuOpenAnimation',
        value: function getMenuOpenAnimation(menuMode) {
            var _props = this.props,
                openAnimation = _props.openAnimation,
                openTransitionName = _props.openTransitionName;

return Menu;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["default"] = (Menu);

Menu.Divider = __WEBPACK_IMPORTED_MODULE_7_rc_menu__["d" /* Divider */];
Menu.Item = __WEBPACK_IMPORTED_MODULE_14__MenuItem__["a" /* default */];
Menu.SubMenu = __WEBPACK_IMPORTED_MODULE_13__SubMenu__["a" /* default */];
Menu.ItemGroup = __WEBPACK_IMPORTED_MODULE_7_rc_menu__["b" /* ItemGroup */];
Menu.defaultProps = {
    prefixCls: 'ant-menu',
    className: '',
    theme: 'light',
    focusable: false
};
Menu.childContextTypes = {
    inlineCollapsed: __WEBPACK_IMPORTED_MODULE_8_prop_types__["bool"],
    antdMenuTheme: __WEBPACK_IMPORTED_MODULE_8_prop_types__["string"]
};
Menu.contextTypes = {
    siderCollapsed: __WEBPACK_IMPORTED_MODULE_8_prop_types__["bool"],
    collapsedWidth: __WEBPACK_IMPORTED_MODULE_8_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_8_prop_types__["number"], __WEBPACK_IMPORTED_MODULE_8_prop_types__["string"]])
};

/***/ }),
/* 92 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(922);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__tooltip_style__ = __webpack_require__(59);

// style dependencies

/***/ }),
/* 93 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _modal = __webpack_require__(118);

var _modal2 = _interopRequireDefault(_modal);

var _select = __webpack_require__(65);

var _select2 = _interopRequireDefault(_select);

__webpack_require__(119);

__webpack_require__(66);

var _EditorHelpers = __webpack_require__(26);

__webpack_require__(896);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

var option = _select2.default.Option;

var BeSelect = function (_React$Component) {
    _inherits(BeSelect, _React$Component);

function BeSelect(props) {
        _classCallCheck(this, BeSelect);

var _this = _possibleConstructorReturn(this, (BeSelect.__proto__ || Object.getPrototypeOf(BeSelect)).call(this, props));

_this.options = null;
        _this.optionsType = null;
        _this.handleChange = _this.handleChange.bind(_this);
        _this.getOptionsList = _this.getOptionsList.bind(_this);
        _this.checkIfValueIsInOptions = _this.checkIfValueIsInOptions.bind(_this);
        return _this;
    }

_createClass(BeSelect, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            if (this.validateOption(this.props.options)) {
                this.options = this.props.options;
                this.optionsType = (0, _EditorHelpers.isImmutable)(this.props.options) ? 'immutable' : 'object';
            }
        }
    }, {
        key: 'validateOption',
        value: function validateOption(option) {
            return (0, _EditorHelpers.isValidDataStructure)(option) && (0, _EditorHelpers.validateValues)(option);
        }
    }, {
        key: 'validateValue',
        value: function validateValue(value) {
            return 'string' == typeof value;
        }
    }, {
        key: 'handleChange',
        value: function handleChange(value) {
            if (value == 'pro') {
                _modal2.default.confirm({
                    title: 'Tatsu Pro required!',
                    content: 'Upgrade to “Tatsu Pro” to enable Dynamic fields integration.',
                    iconType: 'info-circle',
                    className: 'tatsu-pro-upsell',
                    okText: 'Buy Tatsu Pro',
                    onOk: function onOk() {
                        window.open('https://tatsubuilder.com/', '_blank');
                    }
                });
            } else {
                this.props.onChange(value);
            }
        }
    }, {
        key: 'getOptionsList',
        value: function getOptionsList() {
            var _this2 = this;

return 'immutable' == this.optionsType ? this.options.map(function (value, key) {
                return React.createElement(
                    Option,
                    { value: key },
                    value
                );
            }) : Object.keys(this.options).map(function (key) {
                return React.createElement(
                    Option,
                    { value: key },
                    _this2.options[key]
                );
            });
        }
    }, {
        key: 'checkIfValueIsInOptions',
        value: function checkIfValueIsInOptions(value) {
            return 'immutable' == this.optionsType ? this.options.has(value) : this.options.hasOwnProperty(value);
        }
    }, {
        key: 'render',
        value: function render() {
            if (null != this.options) {
                var value = this.validateValue(this.props.value) ? this.props.value : '';
                var selectProps = {
                    onSelect: this.handleChange
                };
                if (this.checkIfValueIsInOptions(value)) {
                    selectProps.value = value;
                }
                return React.createElement(
                    'div',
                    { className: (this.props.className || '') + " be-ui-component be-select" },
                    this.options && React.createElement(
                        _select2.default,
                        _extends({ showSearch: true }, selectProps, { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentNode;
                            } }),
                        this.getOptionsList()
                    )
                );
            } else {
                return null;
            }
        }
    }]);

return BeSelect;
}(React.Component);

exports.default = BeSelect;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 94 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var isEmpty = __webpack_require__(5);

module.exports = function (colorPickerData) {
    var colorValue = '';
    if (typeof colorPickerData == 'string') {
        return { color: colorPickerData, type: 'solid' };
    } else {
        if (Immutable.Map.isMap(colorPickerData)) {
            colorPickerData = colorPickerData.toJS();
        }
        if (colorPickerData.hasOwnProperty('active')) {
            if (colorPickerData.active == 'solid') {
                return { color: colorPickerData.solid.color, type: 'solid' };
            } else {
                return { color: computeGradient(colorPickerData.gradient.color), type: 'gradient' };
            }
        } else if (colorPickerData.hasOwnProperty('id')) {
            if (typeof colorPickerData.color == 'string') {
                return { color: colorPickerData.color, type: 'solid' };
            } else {
                return { color: computeGradient(colorPickerData.color), type: 'gradient' };
            }
        } else {
            return { color: computeGradient(colorPickerData), type: 'gradient' };
        }
    }
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 95 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _components = __webpack_require__(694);

Object.defineProperty(exports, 'screenVisibilityOption', {
  enumerable: true,
  get: function get() {
    return _components.screenVisibilityOption;
  }
});
Object.defineProperty(exports, 'getDrawerTransitionObj', {
  enumerable: true,
  get: function get() {
    return _components.getDrawerTransitionObj;
  }
});
Object.defineProperty(exports, 'getPopoverTransitionObj', {
  enumerable: true,
  get: function get() {
    return _components.getPopoverTransitionObj;
  }
});
Object.defineProperty(exports, 'validWidthUnits', {
  enumerable: true,
  get: function get() {
    return _components.validWidthUnits;
  }
});
Object.defineProperty(exports, 'validDrawerPlacements', {
  enumerable: true,
  get: function get() {
    return _components.validDrawerPlacements;
  }
});
Object.defineProperty(exports, 'birdsEyeViewMenu', {
  enumerable: true,
  get: function get() {
    return _components.birdsEyeViewMenu;
  }
});
Object.defineProperty(exports, 'boxShadowPresets', {
  enumerable: true,
  get: function get() {
    return _components.boxShadowPresets;
  }
});

var _inlineWidth = __webpack_require__(695);

Object.defineProperty(exports, 'inlineFields', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_inlineWidth).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ }),
/* 96 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, jQuery) {

var computeColorforCSS = __webpack_require__(94),
    getAttsBasedOnDisplay = __webpack_require__(53),
    getCSSUnitAndValue = __webpack_require__(237),
    isEmpty = __webpack_require__(5),
    modifyAttsBeforeCSSCompute = __webpack_require__(719);

var getCSSValue = function getCSSValue(styleObj, selector, attType, attValue, attProperty, selectorDetails) {

// Map Value to a Property
    if (attValue != '') {
        // Multiple Property 
        if (Immutable.List.isList(attProperty)) {
            attProperty.forEach(function (property) {
                styleObj = getCSSValue(styleObj, selector, attType, attValue, property, selectorDetails);
            });
        }

var prepend = selectorDetails.has('prepend') ? selectorDetails.get('prepend') : '',
            append = selectorDetails.has('append') ? selectorDetails.get('append') : '';

if (append === ' !important' && attType != 'color') {
            append = '';
        } else if ((attType === 'slider' || attType === 'number') && getCSSUnitAndValue(attValue).unit) {
            append = '';
        }

//Map Property and Value in styleObj  
        styleObj[selector][attProperty] = prepend + attValue + append;

// Modify value if Type is Color
        if (attType == 'color') {
            delete styleObj[selector][attProperty];
            var computedColor = computeColorforCSS(attValue);

computedColor.color = prepend + computedColor.color + '' + append; //Add prepend and append to the newly computed color

if ('border' === attProperty || 'border-color' === attProperty) {
                if ('gradient' === computedColor.type) {
                    styleObj[selector]['border-image'] = computedColor.color;
                    styleObj[selector]['border-image-slice'] = 1;
                } else if ('solid' === computedColor.type) {
                    styleObj[selector]['border-image'] = 'none';
                    styleObj[selector][attProperty] = computedColor.color;
                }
            } else if ('background' === attProperty || 'background-color' === attProperty) {
                if ('gradient' === computedColor.type) {
                    styleObj[selector]['background-image'] = computedColor.color;
                } else {
                    styleObj[selector][attProperty] = computedColor.color;
                }
            } else if ('color' === attProperty) {
                if ('gradient' === computedColor.type) {
                    styleObj[selector]['background'] = computedColor.color;
                    styleObj[selector]['-webkit-background-clip'] = 'text';
                    styleObj[selector]['-webkit-text-fill-color'] = 'transparent';
                } else {
                    styleObj[selector]['color'] = computedColor.color;
                }
            } else {
                if ('gradient' === computedColor.type) {
                    styleObj[selector]['background'] = computedColor.color;
                    styleObj[selector]['-webkit-background-clip'] = 'text';
                    styleObj[selector]['-webkit-text-fill-color'] = 'transparent';
                } else {
                    styleObj[selector][attProperty] = computedColor.color;
                }
            }
        }

if (attType === 'typography') {
            attValue.forEach(function (val, prop) {
                if (prop === 'font-variant') {
                    var weightAndStyle = getCSSUnitAndValue(val);
                    styleObj[selector]['font-weight'] = weightAndStyle.value;
                    if (weightAndStyle.unit !== '') {
                        styleObj[selector]['font-style'] = weightAndStyle.unit;
                    }
                } else if (prop === 'font-family') {
                    styleObj[selector][prop] = getFontFamily(val);
                } else {
                    styleObj[selector][prop] = val;
                }
            });
        }

// Modify value based on Properties
        if (attProperty == 'background-image') {
            styleObj[selector][attProperty] = 'url(' + attValue + ')';
        } else if (attProperty == 'transform') {
            var valueArray = attValue.split(' ');
            styleObj[selector][attProperty] = 'translate3d(' + valueArray[0] + ',' + valueArray[1] + ', 0)';
        } else if (attProperty == 'transformX') {
            delete styleObj[selector][attProperty];
            styleObj[selector]['transform'] = 'translateX(' + prepend + attValue + append + ')';
        } else if (attProperty == 'transformY') {
            delete styleObj[selector][attProperty];
            styleObj[selector]['transform'] = 'translateY(' + prepend + attValue + append + ')';
        } else if (attProperty == 'translateY') {
            delete styleObj[selector][attProperty];
            styleObj[selector]['transform'] = attProperty + '(' + prepend + attValue + append + ')';
        }
    }

return styleObj;
};

var getFontFamily = function getFontFamily(font) {

if (window.typehub_font_options) {
        var standardFonts = window.typehub_font_options.standard;
        var sourceAndFont = font.split(":");
        if (sourceAndFont[1]) {
            switch (sourceAndFont[0]) {
                case 'schemes':
                    var schemes = window.typehub_font_options.schemes;
                    if (schemes[sourceAndFont[1]]) {
                        return getFontFamily(schemes[sourceAndFont[1]].fontFamily);
                    } else {
                        return standardFonts['System Font Stack'];
                    }
                case 'typekit':
                    var typekitFonts = window.typehub_font_options.typekit;
                    if (typekitFonts) {
                        if (typekitFonts[sourceAndFont[1]]) {
                            return typekitFonts[sourceAndFont[1]].cssname;
                        }
                    }
                    break;
                case 'standard':
                    if (standardFonts[sourceAndFont[1]]) {
                        return standardFonts[sourceAndFont[1]];
                    }
                    break;
                default:
                    return '"' + sourceAndFont[1] + '"';
            }
        } else {
            return sourceAndFont[0];
        }
    }
};

var validateCondition = function validateCondition(condition, moduleAtts, display) {

var selectorLoop = function selectorLoop(attsFromModuleOptions, moduleAtts, moduleKey, moduleType, display) {

var selector = selectorList[0].trim();

if (!styleObj.hasOwnProperty(selector)) {
                    styleObj[selector] = {};
                }

if (val.has('when')) {
                    if (val.has('relation')) {
                        if ('and' == val.get('relation')) {
                            if (val.get('when').every(function (condition) {
                                return validateCondition(condition, moduleAtts, display);
                            })) {
                                styleObj = getCSSValue(styleObj, selector, attType, moduleAtts.get(attMap.get('att_name')), val.get('property'), val);
                            }
                        } else {
                            if (val.get('when').some(function (condition) {
                                return validateCondition(condition, moduleAtts, display);
                            })) {
                                styleObj = getCSSValue(styleObj, selector, attType, moduleAtts.get(attMap.get('att_name')), val.get('property'), val);
                            }
                        }
                    } else {
                        if (Immutable.Map.isMap(val.get('when').get(0))) {
                            conditionArray = val.get('when').get(0);
                        } else {
                            conditionArray = val.get('when');
                        }
                        if (validateCondition(conditionArray, moduleAtts, display)) {
                            styleObj = getCSSValue(styleObj, selector, attType, moduleAtts.get(attMap.get('att_name')), val.get('property'), val);
                        }
                    }
                } else {
                    styleObj = getCSSValue(styleObj, selector, attType, moduleAtts.get(attMap.get('att_name')), val.get('property'), val);
                }

//Apply styling when Multiple selectors are present
                if (selectorList.length > 1) {
                    selectorList.map(function (value, key) {
                        if (key >= 1) {
                            var thisSelector = moduleType == 'child' ? value.replace('tatsu-{UUID}', moduleKey) : value.replace('.tatsu-{UUID}', '');
                            thisSelector = thisSelector.trim();
                            if (!styleObj.hasOwnProperty(thisSelector)) {
                                styleObj[thisSelector] = {};
                            }
                            styleObj[thisSelector] = jQuery.extend({}, styleObj[selector], styleObj[thisSelector]);
                        }
                    });
                }

return styleObj;
            }, styleObj);
        } else {
            return styleObj;
        }
    }, styleObj) : styleObj;
};

module.exports = function (module, display, moduleOptions) {

var styleObj = {},
        moduleName,
        attsFromModuleOptions,
        moduleAtts,
        subModule,
        moduleKey,
        currentSubModule;

moduleName = module.get('name');
    moduleKey = module.get('id');
    attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']);
    moduleAtts = getAttsBasedOnDisplay(module.get('atts'), display, attsFromModuleOptions);
    moduleAtts = modifyAttsBeforeCSSCompute[moduleName] ? modifyAttsBeforeCSSCompute[moduleName](moduleAtts) : moduleAtts;
    styleObj = selectorLoop(attsFromModuleOptions, moduleAtts, moduleKey, 'parent', display);

if (module.get('type') === 'multi') {
        subModule = moduleOptions.getIn([moduleName, 'child_module']);
        // To Handle different Types of Sub Modules
        if (Immutable.List.isList(subModule)) {
            subModule.map(function (value, key) {
                currentSubModule = value;
                module.getIn(['inner']).map(function (value, key) {
                    moduleKey = value.get('id');
                    attsFromModuleOptions = moduleOptions.getIn([currentSubModule, 'atts']);
                    moduleAtts = getAttsBasedOnDisplay(value.get('atts'), display, attsFromModuleOptions);
                    moduleAtts = modifyAttsBeforeCSSCompute[currentSubModule] ? modifyAttsBeforeCSSCompute[currentSubModule](moduleAtts) : moduleAtts;
                    styleObj = jQuery.extend({}, styleObj, selectorLoop(attsFromModuleOptions, moduleAtts, moduleKey, 'child', display));
                });
            });
        } else {
            module.getIn(['inner']).map(function (value, key) {
                moduleKey = value.get('id');
                attsFromModuleOptions = moduleOptions.getIn([subModule, 'atts']);
                moduleAtts = getAttsBasedOnDisplay(value.get('atts'), display, attsFromModuleOptions);
                moduleAtts = modifyAttsBeforeCSSCompute[subModule] ? modifyAttsBeforeCSSCompute[subModule](moduleAtts) : moduleAtts;
                styleObj = jQuery.extend({}, styleObj, selectorLoop(attsFromModuleOptions, moduleAtts, moduleKey, 'child', value.get('name'), display));
            });
        }
    }

return styleObj;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 97 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function (selectionState) {

if (!Immutable.Map(selectionState)) {
        return Immutable.List();
    } else if ('single' == selectionState.get('type')) {
        return selectionState.getIn(['selectionList', 0, 'path']);
    } else if ('multi' == selectionState.get('type')) {
        return selectionState.get('selectionList').map(function (curSelection) {

return curSelection.get('path');
        });
    }
    return Immutable.List();
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 98 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var store = __webpack_require__(11),
    getKeyPath = __webpack_require__(39);

module.exports = function (path, level) {
    var pageContent = store.getState().tatsu_page_content.get('present'),
        parentPath = level === 'current' ? path : path.pop(),
        parentComponent;
    level = 'undefined' == typeof level ? '' : level;
    if ('undefined' != typeof pageContent) {
        parentComponent = pageContent.getIn(getKeyPath(parentPath));
    }

return parentComponent;
};

/***/ }),
/* 99 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var store = __webpack_require__(11),
    closeDrawer = __webpack_require__(2).closeDrawer,
    setSelection = __webpack_require__(2).setSelection,
    changeTargetDisplay = __webpack_require__(2).changeTargetDisplay;

module.exports = function (path, event) {
    // if( 1 == event.buttons ) {
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    var currentPlatform = -1 < window.navigator.userAgent.toUpperCase().indexOf('MAC') ? 'metaKey' : 'ctrlKey',
        selectionType = event[currentPlatform] ? 'multi' : 'single',
        currentDocument = document.getElementById('tatsu-preview').contentDocument;
    if (-1 < document.body.className.indexOf("preview")) {
        return;
    }
    if (-1 < document.body.className.indexOf('mce-fullscreen')) {
        tinymce.activeEditor.execCommand('mceFullScreen');
    }

store.dispatch(closeDrawer());
    store.dispatch(setSelection(path, selectionType));
    // store.dispatch( 
    //     changeTargetDisplay( 'desktop' ) 
    // );
    // }
    event.stopPropagation();
};

/***/ }),
/* 100 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(103);
module.exports = function (it) {
  if (!isObject(it)) throw TypeError(it + ' is not an object!');
  return it;
};

/***/ }),
/* 101 */
/***/ (function(module, exports) {

module.exports = function (exec) {
  try {
    return !!exec();
  } catch (e) {
    return true;
  }
};

/***/ }),
/* 102 */
/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(71);
var createDesc = __webpack_require__(129);
module.exports = __webpack_require__(68) ? function (object, key, value) {
  return dP.f(object, key, createDesc(1, value));
} : function (object, key, value) {
  object[key] = value;
  return object;
};

/***/ }),
/* 103 */
/***/ (function(module, exports) {

module.exports = function (it) {
  return typeof it === 'object' ? it !== null : typeof it === 'function';
};

/***/ }),
/* 104 */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.13 ToObject(argument)
var defined = __webpack_require__(247);
module.exports = function (it) {
  return Object(defined(it));
};

/***/ }),
/* 105 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Indicates that navigation was caused by a call to history.push.
 */

exports.__esModule = true;
var PUSH = 'PUSH';

exports.PUSH = PUSH;
/**
 * Indicates that navigation was caused by a call to history.replace.
 */
var REPLACE = 'REPLACE';

exports.REPLACE = REPLACE;
/**
 * Indicates that navigation was caused by some other action such
 * as using a browser's back/forward buttons and/or manually manipulating
 * the URL in a browser's location bar. This is the default.
 *
 * See https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onpopstate
 * for more information.
 */
var POP = 'POP';

exports.POP = POP;
exports['default'] = {
  PUSH: PUSH,
  REPLACE: REPLACE,
  POP: POP
};

/***/ }),
/* 106 */
/***/ (function(module, exports, __webpack_require__) {

var root = __webpack_require__(45);

/** Built-in value references. */
var Symbol = root.Symbol;

module.exports = Symbol;

/***/ }),
/* 107 */
/***/ (function(module, exports) {

/**
 * A specialized version of `_.map` for arrays without support for iteratee
 * shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 */
function arrayMap(array, iteratee) {
  var index = -1,
      length = array == null ? 0 : array.length,
      result = Array(length);

while (++index < length) {
    result[index] = iteratee(array[index], index, array);
  }
  return result;
}

module.exports = arrayMap;

/***/ }),
/* 108 */
/***/ (function(module, exports, __webpack_require__) {

var identity = __webpack_require__(178),
    overRest = __webpack_require__(451),
    setToString = __webpack_require__(452);

/**
 * The base implementation of `_.rest` which doesn't validate or coerce arguments.
 *
 * @private
 * @param {Function} func The function to apply a rest parameter to.
 * @param {number} [start=func.length-1] The start position of the rest parameter.
 * @returns {Function} Returns the new function.
 */
function baseRest(func, start) {
  return setToString(overRest(func, start, identity), func + '');
}

module.exports = baseRest;

/***/ }),
/* 109 */
/***/ (function(module, exports, __webpack_require__) {

var assignValue = __webpack_require__(278),
    baseAssignValue = __webpack_require__(426);

/**
 * Copies properties of `source` to `object`.
 *
 * @private
 * @param {Object} source The object to copy properties from.
 * @param {Array} props The property identifiers to copy.
 * @param {Object} [object={}] The object to copy properties to.
 * @param {Function} [customizer] The function to customize copied values.
 * @returns {Object} Returns `object`.
 */
function copyObject(source, props, object, customizer) {
  var isNew = !object;
  object || (object = {});

var index = -1,
      length = props.length;

while (++index < length) {
    var key = props[index];

var newValue = customizer
      ? customizer(object[key], source[key], key, object, source)
      : undefined;

if (newValue === undefined) {
      newValue = source[key];
    }
    if (isNew) {
      baseAssignValue(object, key, newValue);
    } else {
      assignValue(object, key, newValue);
    }
  }
  return object;
}

module.exports = copyObject;

/***/ }),
/* 110 */
/***/ (function(module, exports, __webpack_require__) {

var arrayLikeKeys = __webpack_require__(425),
    baseKeys = __webpack_require__(432),
    isArrayLike = __webpack_require__(73);

/**
 * Creates an array of the own enumerable property names of `object`.
 *
 * **Note:** Non-object values are coerced to objects. See the
 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
 * for more details.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.keys(new Foo);
 * // => ['a', 'b'] (iteration order is not guaranteed)
 *
 * _.keys('hi');
 * // => ['0', '1']
 */
function keys(object) {
  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
}

module.exports = keys;

/***/ }),
/* 111 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = noop;
/* harmony export (immutable) */ __webpack_exports__["c"] = getKeyFromChildrenIndex;
/* harmony export (immutable) */ __webpack_exports__["h"] = getMenuIdFromSubMenuEventKey;
/* harmony export (immutable) */ __webpack_exports__["b"] = loopMenuItem;
/* harmony export (immutable) */ __webpack_exports__["i"] = loopMenuItemRecursively;
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return menuAllProps; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return getWidth; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return setStyle; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return isMobileDevice; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__utils_isMobile__ = __webpack_require__(1147);
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

if (c && c.type && c.type.isMenuItemGroup) {
      __WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.forEach(c.props.children, function (c2) {
        index += 1;
        cb(c2, index);
      });
    } else {
      cb(c, index);
    }
  });
}
function loopMenuItemRecursively(children, keys, ret) {
  /* istanbul ignore if */
  if (!children || ret.find) {
    return;
  }

__WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.forEach(children, function (c) {
    if (c) {
      var construct = c.type;

if (!construct || !(construct.isSubMenu || construct.isMenuItem || construct.isMenuItemGroup)) {
        return;
      }

if (keys.indexOf(c.key) !== -1) {
        ret.find = true;
      } else if (c.props.children) {
        loopMenuItemRecursively(c.props.children, keys, ret);
      }
    }
  });
}
var menuAllProps = ['defaultSelectedKeys', 'selectedKeys', 'defaultOpenKeys', 'openKeys', 'mode', 'getPopupContainer', 'onSelect', 'onDeselect', 'onDestroy', 'openTransitionName', 'openAnimation', 'subMenuOpenDelay', 'subMenuCloseDelay', 'forceSubMenuRender', 'triggerSubMenuAction', 'level', 'selectable', 'multiple', 'onOpenChange', 'visible', 'focusable', 'defaultActiveFirst', 'prefixCls', 'inlineIndent', 'parentMenu', 'title', 'rootPrefixCls', 'eventKey', 'active', 'onItemHover', 'onTitleMouseEnter', 'onTitleMouseLeave', 'onTitleClick', 'popupAlign', 'popupOffset', 'isOpen', 'renderMenuItem', 'manualRef', 'subMenuKey', 'disabled', 'index', 'isSelected', 'store', 'activeKey', 'builtinPlacements', 'overflowedIndicator', // the following keys found need to be removed from test regression
'attribute', 'value', 'popupClassName', 'inlineCollapsed', 'menu', 'theme', 'itemIcon', 'expandIcon']; // ref: https://github.com/ant-design/ant-design/issues/14007
// ref: https://bugs.chromium.org/p/chromium/issues/detail?id=360889
// getBoundingClientRect return the full precision value, which is
// not the same behavior as on chrome. Set the precision to 6 to
// unify their behavior

var getWidth = function getWidth(elem) {
  var width = elem && typeof elem.getBoundingClientRect === 'function' && elem.getBoundingClientRect().width;

if (width) {
    width = +width.toFixed(6);
  }

return width || 0;
};
var setStyle = function setStyle(elem, styleProperty, value) {
  if (elem && _typeof(elem.style) === 'object') {
    elem.style[styleProperty] = value;
  }
};
var isMobileDevice = function isMobileDevice() {
  return __WEBPACK_IMPORTED_MODULE_1__utils_isMobile__["a" /* default */].any;
};

/***/ }),
/* 112 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.compilePattern = compilePattern;
exports.matchPattern = matchPattern;
exports.getParamNames = getParamNames;
exports.getParams = getParams;
exports.formatPattern = formatPattern;

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

function _compilePattern(pattern) {
  var regexpSource = '';
  var paramNames = [];
  var tokens = [];

var match = void 0,
      lastIndex = 0,
      matcher = /:([a-zA-Z_$][a-zA-Z0-9_$]*)|\*\*|\*|$|$/g;
  while (match = matcher.exec(pattern)) {
    if (match.index !== lastIndex) {
      tokens.push(pattern.slice(lastIndex, match.index));
      regexpSource += escapeRegExp(pattern.slice(lastIndex, match.index));
    }

if (match[1]) {
      regexpSource += '([^/]+)';
      paramNames.push(match[1]);
    } else if (match[0] === '**') {
      regexpSource += '(.*)';
      paramNames.push('splat');
    } else if (match[0] === '*') {
      regexpSource += '(.*?)';
      paramNames.push('splat');
    } else if (match[0] === '(') {
      regexpSource += '(?:';
    } else if (match[0] === ')') {
      regexpSource += ')?';
    }

tokens.push(match[0]);

lastIndex = matcher.lastIndex;
  }

if (lastIndex !== pattern.length) {
    tokens.push(pattern.slice(lastIndex, pattern.length));
    regexpSource += escapeRegExp(pattern.slice(lastIndex, pattern.length));
  }

return {
    pattern: pattern,
    regexpSource: regexpSource,
    paramNames: paramNames,
    tokens: tokens
  };
}

var CompiledPatternsCache = Object.create(null);

function compilePattern(pattern) {
  if (!CompiledPatternsCache[pattern]) CompiledPatternsCache[pattern] = _compilePattern(pattern);

return CompiledPatternsCache[pattern];
}

/**
 * Attempts to match a pattern on the given pathname. Patterns may use
 * the following special characters:
 *
 * - :paramName     Matches a URL segment up to the next /, ?, or #. The
 *                  captured string is considered a "param"
 * - ()             Wraps a segment of the URL that is optional
 * - *              Consumes (non-greedy) all characters up to the next
 *                  character in the pattern, or to the end of the URL if
 *                  there is none
 * - **             Consumes (greedy) all characters up to the next character
 *                  in the pattern, or to the end of the URL if there is none
 *
 *  The function calls callback(error, matched) when finished.
 * The return value is an object with the following properties:
 *
 * - remainingPathname
 * - paramNames
 * - paramValues
 */
function matchPattern(pattern, pathname) {
  // Ensure pattern starts with leading slash for consistency with pathname.
  if (pattern.charAt(0) !== '/') {
    pattern = '/' + pattern;
  }

var _compilePattern2 = compilePattern(pattern);

var regexpSource = _compilePattern2.regexpSource;
  var paramNames = _compilePattern2.paramNames;
  var tokens = _compilePattern2.tokens;

if (pattern.charAt(pattern.length - 1) !== '/') {
    regexpSource += '/?'; // Allow optional path separator at end.
  }

// Special-case patterns like '*' for catch-all routes.
  if (tokens[tokens.length - 1] === '*') {
    regexpSource += '$';
  }

var match = pathname.match(new RegExp('^' + regexpSource, 'i'));
  if (match == null) {
    return null;
  }

var matchedPath = match[0];
  var remainingPathname = pathname.substr(matchedPath.length);

if (remainingPathname) {
    // Require that the match ends at a path separator, if we didn't match
    // the full path, so any remaining pathname is a new path segment.
    if (matchedPath.charAt(matchedPath.length - 1) !== '/') {
      return null;
    }

// If there is a remaining pathname, treat the path separator as part of
    // the remaining pathname for properly continuing the match.
    remainingPathname = '/' + remainingPathname;
  }

return {
    remainingPathname: remainingPathname,
    paramNames: paramNames,
    paramValues: match.slice(1).map(function (v) {
      return v && decodeURIComponent(v);
    })
  };
}

function getParamNames(pattern) {
  return compilePattern(pattern).paramNames;
}

function getParams(pattern, pathname) {
  var match = matchPattern(pattern, pathname);
  if (!match) {
    return null;
  }

var paramNames = match.paramNames;
  var paramValues = match.paramValues;

var params = {};

paramNames.forEach(function (paramName, index) {
    params[paramName] = paramValues[index];
  });

return params;
}

/**
 * Returns a version of the given pattern with params interpolated. Throws
 * if there is a dynamic segment of the pattern for which there is no param.
 */
function formatPattern(pattern, params) {
  params = params || {};

var _compilePattern3 = compilePattern(pattern);

var tokens = _compilePattern3.tokens;

var parenCount = 0,
      pathname = '',
      splatIndex = 0;

var token = void 0,
      paramName = void 0,
      paramValue = void 0;
  for (var i = 0, len = tokens.length; i < len; ++i) {
    token = tokens[i];

if (token === '*' || token === '**') {
      paramValue = Array.isArray(params.splat) ? params.splat[splatIndex++] : params.splat;

!(paramValue != null || parenCount > 0) ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, 'Missing splat #%s for path "%s"', splatIndex, pattern) : (0, _invariant2.default)(false) : void 0;

if (paramValue != null) pathname += encodeURI(paramValue);
    } else if (token === '(') {
      parenCount += 1;
    } else if (token === ')') {
      parenCount -= 1;
    } else if (token.charAt(0) === ':') {
      paramName = token.substring(1);
      paramValue = params[paramName];

!(paramValue != null || parenCount > 0) ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, 'Missing "%s" parameter for path "%s"', paramName, pattern) : (0, _invariant2.default)(false) : void 0;

if (paramValue != null) pathname += encodeURIComponent(paramValue);
    } else {
      pathname += token;
    }
  }

return pathname.replace(/\/+/g, '/');
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 113 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule DOMLazyTree
 */

var DOMNamespaces = __webpack_require__(318);
var setInnerHTML = __webpack_require__(198);

var createMicrosoftUnsafeLocalFunction = __webpack_require__(331);
var setTextContent = __webpack_require__(544);

var ELEMENT_NODE_TYPE = 1;
var DOCUMENT_FRAGMENT_NODE_TYPE = 11;

/**
 * In IE (8-11) and Edge, appending nodes with no children is dramatically
 * faster than appending a full subtree, so we essentially queue up the
 * .appendChild calls here and apply them so each node is added to its parent
 * before any children are added.
 *
 * In other browsers, doing so is slower or neutral compared to the other order
 * (in Firefox, twice as slow) so we only do this inversion in IE.
 *
 * See https://github.com/spicyj/innerhtml-vs-createelement-vs-clonenode.
 */
var enableLazy = typeof document !== 'undefined' && typeof document.documentMode === 'number' || typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string' && /\bEdge\/\d/.test(navigator.userAgent);

function replaceChildWithTree(oldNode, newTree) {
  oldNode.parentNode.replaceChild(newTree.node, oldNode);
  insertTreeChildren(newTree);
}

function queueChild(parentTree, childTree) {
  if (enableLazy) {
    parentTree.children.push(childTree);
  } else {
    parentTree.node.appendChild(childTree.node);
  }
}

function queueHTML(tree, html) {
  if (enableLazy) {
    tree.html = html;
  } else {
    setInnerHTML(tree.node, html);
  }
}

function queueText(tree, text) {
  if (enableLazy) {
    tree.text = text;
  } else {
    setTextContent(tree.node, text);
  }
}

function toString() {
  return this.node.nodeName;
}

function DOMLazyTree(node) {
  return {
    node: node,
    children: [],
    html: null,
    text: null,
    toString: toString
  };
}

DOMLazyTree.insertTreeBefore = insertTreeBefore;
DOMLazyTree.replaceChildWithTree = replaceChildWithTree;
DOMLazyTree.queueChild = queueChild;
DOMLazyTree.queueHTML = queueHTML;
DOMLazyTree.queueText = queueText;

module.exports = DOMLazyTree;

/***/ }),
/* 114 */
/***/ (function(module, exports, __webpack_require__) {

var ReactRef = __webpack_require__(1401);
var ReactInstrumentation = __webpack_require__(41);

var warning = __webpack_require__(18);

/**
 * Helper to call ReactRef.attachRefs with this composite component, split out
 * to avoid allocations in the transaction mount-ready queue.
 */
function attachRefs() {
  ReactRef.attachRefs(this, this._currentElement);
}

var ReactReconciler = {

/**
   * Initializes the component, renders markup, and registers event listeners.
   *
   * @param {ReactComponent} internalInstance
   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
   * @param {?object} the containing host component instance
   * @param {?object} info about the host container
   * @return {?string} Rendered markup to be inserted into the DOM.
   * @final
   * @internal
   */
  mountComponent: function (internalInstance, transaction, hostParent, hostContainerInfo, context, parentDebugID // 0 in production and for roots
  ) {
    if (process.env.NODE_ENV !== 'production') {
      if (internalInstance._debugID !== 0) {
        ReactInstrumentation.debugTool.onBeforeMountComponent(internalInstance._debugID, internalInstance._currentElement, parentDebugID);
      }
    }
    var markup = internalInstance.mountComponent(transaction, hostParent, hostContainerInfo, context, parentDebugID);
    if (internalInstance._currentElement && internalInstance._currentElement.ref != null) {
      transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
    }
    if (process.env.NODE_ENV !== 'production') {
      if (internalInstance._debugID !== 0) {
        ReactInstrumentation.debugTool.onMountComponent(internalInstance._debugID);
      }
    }
    return markup;
  },

/**
   * Returns a value that can be passed to
   * ReactComponentEnvironment.replaceNodeWithMarkup.
   */
  getHostNode: function (internalInstance) {
    return internalInstance.getHostNode();
  },

/**
   * Releases any resources allocated by `mountComponent`.
   *
   * @final
   * @internal
   */
  unmountComponent: function (internalInstance, safely) {
    if (process.env.NODE_ENV !== 'production') {
      if (internalInstance._debugID !== 0) {
        ReactInstrumentation.debugTool.onBeforeUnmountComponent(internalInstance._debugID);
      }
    }
    ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
    internalInstance.unmountComponent(safely);
    if (process.env.NODE_ENV !== 'production') {
      if (internalInstance._debugID !== 0) {
        ReactInstrumentation.debugTool.onUnmountComponent(internalInstance._debugID);
      }
    }
  },

/**
   * Update a component using a new element.
   *
   * @param {ReactComponent} internalInstance
   * @param {ReactElement} nextElement
   * @param {ReactReconcileTransaction} transaction
   * @param {object} context
   * @internal
   */
  receiveComponent: function (internalInstance, nextElement, transaction, context) {
    var prevElement = internalInstance._currentElement;

if (nextElement === prevElement && context === internalInstance._context) {
      // Since elements are immutable after the owner is rendered,
      // we can do a cheap identity compare here to determine if this is a
      // superfluous reconcile. It's possible for state to be mutable but such
      // change should trigger an update of the owner which would recreate
      // the element. We explicitly check for the existence of an owner since
      // it's possible for an element created outside a composite to be
      // deeply mutated and reused.

// TODO: Bailing out early is just a perf optimization right?
      // TODO: Removing the return statement should affect correctness?
      return;
    }

if (process.env.NODE_ENV !== 'production') {
      if (internalInstance._debugID !== 0) {
        ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, nextElement);
      }
    }

var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement);

if (refsChanged) {
      ReactRef.detachRefs(internalInstance, prevElement);
    }

internalInstance.receiveComponent(nextElement, transaction, context);

if (refsChanged && internalInstance._currentElement && internalInstance._currentElement.ref != null) {
      transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
    }

if (process.env.NODE_ENV !== 'production') {
      if (internalInstance._debugID !== 0) {
        ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
      }
    }
  },

/**
   * Flush any dirty changes in a component.
   *
   * @param {ReactComponent} internalInstance
   * @param {ReactReconcileTransaction} transaction
   * @internal
   */
  performUpdateIfNecessary: function (internalInstance, transaction, updateBatchNumber) {
    if (internalInstance._updateBatchNumber !== updateBatchNumber) {
      // The component's enqueued batch number should always be the current
      // batch or the following one.
      process.env.NODE_ENV !== 'production' ? warning(internalInstance._updateBatchNumber == null || internalInstance._updateBatchNumber === updateBatchNumber + 1, 'performUpdateIfNecessary: Unexpected batch number (current %s, ' + 'pending %s)', updateBatchNumber, internalInstance._updateBatchNumber) : void 0;
      return;
    }
    if (process.env.NODE_ENV !== 'production') {
      if (internalInstance._debugID !== 0) {
        ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, internalInstance._currentElement);
      }
    }
    internalInstance.performUpdateIfNecessary(transaction);
    if (process.env.NODE_ENV !== 'production') {
      if (internalInstance._debugID !== 0) {
        ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
      }
    }
  }

};

module.exports = ReactReconciler;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 115 */
/***/ (function(module, exports) {

module.exports = function shallowEqual(objA, objB, compare, compareContext) {
  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;

if (ret !== void 0) {
    return !!ret;
  }

if (objA === objB) {
    return true;
  }

if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
    return false;
  }

var keysA = Object.keys(objA);
  var keysB = Object.keys(objB);

if (keysA.length !== keysB.length) {
    return false;
  }

var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);

// Test for A's keys different from B.
  for (var idx = 0; idx < keysA.length; idx++) {
    var key = keysA[idx];

if (!bHasOwnProperty(key)) {
      return false;
    }

var valueA = objA[key];
    var valueB = objB[key];

ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;

if (ret === false || (ret === void 0 && valueA !== valueB)) {
      return false;
    }
  }

return true;
};

/***/ }),
/* 116 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = __webpack_require__(1446);

/***/ }),
/* 117 */
/***/ (function(module, exports, __webpack_require__) {

var __DEV__ = process.env.NODE_ENV !== 'production';

var warning = function() {};

if (__DEV__) {
  var printWarning = function printWarning(format, args) {
    var len = arguments.length;
    args = new Array(len > 1 ? len - 1 : 0);
    for (var key = 1; key < len; key++) {
      args[key - 1] = arguments[key];
    }
    var argIndex = 0;
    var message = 'Warning: ' +
      format.replace(/%s/g, function() {
        return args[argIndex++];
      });
    if (typeof console !== 'undefined') {
      console.error(message);
    }
    try {
      // --- Welcome to debugging React ---
      // This error was thrown as a convenience so that you can use this stack
      // to find the callsite that caused this warning to fire.
      throw new Error(message);
    } catch (x) {}
  }

warning = function(condition, format, args) {
    var len = arguments.length;
    args = new Array(len > 2 ? len - 2 : 0);
    for (var key = 2; key < len; key++) {
      args[key - 2] = arguments[key];
    }
    if (format === undefined) {
      throw new Error(
          '`warning(condition, format, ...args)` requires a warning ' +
          'message argument'
      );
    }
    if (!condition) {
      printWarning.apply(null, [format].concat(args));
    }
  };
}

module.exports = warning;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 118 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

__WEBPACK_IMPORTED_MODULE_1__Modal__["a" /* default */].info = function (props) {
    var config = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ type: 'info', iconType: 'info-circle', okCancel: false }, props);
    return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__confirm__["a" /* default */])(config);
};
__WEBPACK_IMPORTED_MODULE_1__Modal__["a" /* default */].success = function (props) {
    var config = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ type: 'success', iconType: 'check-circle', okCancel: false }, props);
    return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__confirm__["a" /* default */])(config);
};
__WEBPACK_IMPORTED_MODULE_1__Modal__["a" /* default */].error = function (props) {
    var config = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ type: 'error', iconType: 'close-circle', okCancel: false }, props);
    return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__confirm__["a" /* default */])(config);
};
__WEBPACK_IMPORTED_MODULE_1__Modal__["a" /* default */].warning = __WEBPACK_IMPORTED_MODULE_1__Modal__["a" /* default */].warn = function (props) {
    var config = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ type: 'warning', iconType: 'exclamation-circle', okCancel: false }, props);
    return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__confirm__["a" /* default */])(config);
};
__WEBPACK_IMPORTED_MODULE_1__Modal__["a" /* default */].confirm = function (props) {
    var config = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ type: 'confirm', okCancel: true }, props);
    return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__confirm__["a" /* default */])(config);
};
/* harmony default export */ __webpack_exports__["default"] = (__WEBPACK_IMPORTED_MODULE_1__Modal__["a" /* default */]);

/***/ }),
/* 119 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(923);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__button_style__ = __webpack_require__(203);

// style dependencies

/***/ }),
/* 120 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

var findDOMNode = __webpack_require__(7).findDOMNode;
module.exports = function (node) {

var currentNode = jQuery(findDOMNode(node)),
		    currentNodeClassNames;
		if (0 != currentNode.length) {
				currentNode.removeClass('animated flipInX flipInY fadeIn fadeInDown fadeInLeft fadeInRight fadeInUp slideInDown slideInLeft slideInRight rollIn rollOut bounce bounceIn bounceInUp bounceInDown bounceInLeft bounceInRight fadeInUpBig fadeInDownBig fadeInLeftBig fadeInRightBig flash flip lightSpeedIn pulse rotateIn rotateInUpLeft rotateInDownLeft rotateInUpRight rotateInDownRight shake swing tada wiggle wobble infiniteJump zoomIn none already-visible end-animation');
				currentNodeClassNames = currentNode.attr('class');
				if (-1 === currentNodeClassNames.indexOf('already-visible') && -1 === currentNodeClassNames.indexOf('animated')) {
						currentNode.addClass('already-visible animated');
				}

currentNode.removeClass('tatsu-animate');
				currentNode.find('.tatsu-animate, .be-animate').removeClass('tatsu-animate be-animate');
		}
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 121 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var throttle = __webpack_require__(296);
module.exports = function () {

var innerDocument,
        scrollTarget = null,
        leftScrollTarget,
        topElement,
        bottomElement,
        innerDocument,
        rightScrollTarget,
        dndScrollMap,
        css = function css(ele, styles) {

var styleAttributes = Object.keys(styles);
        styleAttributes.forEach(function (attr) {

ele.style[attr] = styles[attr];
        });
    },
        triggerScroll = function triggerScroll(ele) {

if (null != scrollTarget) {
            scrollTarget.scrollTop += topElement == ele.target ? -100 : 100;
        }
    },
        show = function show() {

[].forEach.call(arguments, function (arg) {

arg.style.display = "block";
        });
    },
        hide = function hide() {

[].forEach.call(arguments, function (arg) {

arg.style.display = "none";
        });
    },
        appendElementWithId = function appendElementWithId(id, node) {

var element = document.createElement('div');
        element.setAttribute('id', id);
        node.appendChild(element);
        return element;
    },
        populateData = function populateData() {

topElement = appendElementWithId('dnd-page-scroll-top', document.body);
        bottomElement = appendElementWithId('dnd-page-scroll-bottom', document.body);
        innerDocument = document.getElementById('tatsu-preview').contentDocument;
        leftScrollTarget = document.getElementById('be-pb-leftpanel-inner-wrap');
        rightScrollTarget = innerDocument.getElementsByTagName('html')[0];
        dndScrollMap = {
            'tatsu-section-layout-card': leftScrollTarget,
            'be-pb-row-card': leftScrollTarget,
            'be-pb-module-card': leftScrollTarget,
            'tatsu-module-preview': rightScrollTarget,
            'tatsu-draggable-selection-header': rightScrollTarget,
            'be-pb-modulelist-card': rightScrollTarget
        };
    },
        init = function init() {

populateData();
        hide(topElement, bottomElement);
        [topElement, bottomElement].forEach(function (ele, index) {

css(ele, {
                position: 'fixed',
                left: 0,
                height: '70px',
                width: '100%',
                zIndex: 999999
            });
            ele.addEventListener('dragover', throttle(triggerScroll, 50));
        });
        topElement.style.top = '0';
        bottomElement.style.bottom = '0';
    },
        showDragScroll = function showDragScroll(className) {

var curScrollTarget, classNameArray;
        classNameArray = '' == className ? [] : className.toString().split(' ').map(function (curClassName) {

return curClassName.trim();
        });
        curScrollTarget = classNameArray.find(function (curClassName) {

return -1 < Object.keys(dndScrollMap).indexOf(curClassName);
        });
        if (curScrollTarget) {
            show(topElement, bottomElement);
            scrollTarget = dndScrollMap[curScrollTarget];
        }
    },
        hideDragScroll = function hideDragScroll() {

hide(topElement, bottomElement);
        scrollTarget = null;
    };
    return {
        init: init,
        showDragScroll: showDragScroll,
        hideDragScroll: hideDragScroll
    };
}();

/***/ }),
/* 122 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var typewatch = function () {
    var timer = 0;
    return function (callback, ms, args) {
        clearTimeout(timer);
        timer = setTimeout(null == args ? callback : callback.bind(null, args), ms);
    };
}();

module.exports = typewatch;

/***/ }),
/* 123 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var getAttFromDisplay = function getAttFromDisplay(attValue, display) {
    var displayKey = display.charAt('0');
    if (null == attValue.get(displayKey)) {
        return getAttFromDisplay(attValue, 'desktop');
        // return getAttFromDisplay( attValue, 'laptop' == display ? 'desktop' : ( 'tablet' == display ? 'laptop' : 'tablet' ) );
    }
    return attValue.get(displayKey);
};

module.exports = getAttFromDisplay;

/***/ }),
/* 124 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

function CssAnimator(moduleObj, childrenAnimatable) {

var childModuleAtts, childModuleName, childrenAnimatable, filteredChildModuleAtts;
    this.hasAnimatableChildren = childrenAnimatable;
    this.moduleObj = moduleObj;
}
CssAnimator.prototype.updateModuleObj = function (newModuleObj) {

this.moduleObj = newModuleObj;
};
CssAnimator.prototype.triggerAnimation = function (newModuleObj) {
    var targetChildModules,
        animateMessage = {
        type: 'csstrigger',
        animationDetails: {}
    },
        jsonData,
        currentModule = this.moduleObj;
    if (!Immutable.is(this.moduleObj, newModuleObj)) {
        if (this.hasAnimatableChildren && 0 < newModuleObj.get('inner').size) {
            targetChildModules = newModuleObj.get('inner').filter(function (child, index) {

if ('undefined' != typeof currentModule.getIn(['inner', index])) {
                    return '1' == currentModule.getIn(['inner', index, 'atts', 'animate']) && '0' == child.getIn(['atts', 'animate']) || '0' == currentModule.getIn(['inner', index, 'atts', 'animate']) && '1' == child.getIn(['atts', 'animate']) || '1' == child.getIn(['atts', 'animate']) && currentModule.getIn(['inner', index, 'atts', 'animation_type']) != child.getIn(['atts', 'animation_type']) || '1' == child.getIn(['atts', 'animate']) && currentModule.getIn(['inner', index, 'atts', 'animation_delay']) != child.getIn(['atts', 'animation_delay']) || '1' == child.getIn(['atts', 'animate']) && currentModule.getIn(['inner', index, 'atts', 'animation_duration']) != child.getIn(['atts', 'animation_duration']);
                } else {
                    return '1' == child.getIn(['atts', 'animate']) && 'none' !== child.getIn(['atts', 'animation_type']);
                }
            });
            if (0 < targetChildModules.size) {
                this.updateModuleObj(newModuleObj);
                targetChildModules.forEach(function (child) {
                    animateMessage.animationDetails.id = child.get('id');
                    animateMessage.animationDetails.animation = child.getIn(['atts', 'animation_type']);
                    animateMessage.animationDetails.animationDelay = child.getIn(['atts', 'animation_delay']);
                    animateMessage.animationDetails.animationDuration = child.getIn(['atts', 'animation_duration']);
                    jsonData = JSON.stringify(animateMessage);
                    document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
                });
            }
        }

if ('1' == currentModule.getIn(['atts', 'animate']) && '0' == newModuleObj.getIn(['atts', 'animate']) || '1' == newModuleObj.getIn(['atts', 'animate']) && 'none' !== currentModule.getIn(['atts', 'animation_type']) && 'none' == newModuleObj.getIn(['atts', 'animation_type'])) {
            this.updateModuleObj(newModuleObj);
            return;
        } else if ('0' == currentModule.getIn(['atts', 'animate']) && '1' == newModuleObj.getIn(['atts', 'animate']) || '1' == newModuleObj.getIn(['atts', 'animate']) && currentModule.getIn(['atts', 'animation_type']) != newModuleObj.getIn(['atts', 'animation_type']) || '1' == newModuleObj.getIn(['atts', 'animate']) && currentModule.getIn(['atts', 'animation_delay']) != newModuleObj.getIn(['atts', 'animation_delay']) || '1' == newModuleObj.getIn(['atts', 'animate']) && currentModule.getIn(['atts', 'animation_duration']) != newModuleObj.getIn(['atts', 'animation_duration'])) {
            this.updateModuleObj(newModuleObj);
            animateMessage.animationDetails.id = newModuleObj.get('id');
            animateMessage.animationDetails.animation = newModuleObj.getIn(['atts', 'animation_type']);
            animateMessage.animationDetails.animationDelay = newModuleObj.getIn(['atts', 'animation_delay']);
            animateMessage.animationDetails.animationDuration = newModuleObj.getIn(['atts', 'animation_duration']);
            jsonData = JSON.stringify(animateMessage);
            document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
        }
    }
};
CssAnimator.prototype.init = function () {

/***/ }),
/* 125 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var RenderInBody = React.createClass({
  displayName: "RenderInBody",

componentDidMount: function componentDidMount() {
    this.popup = document.createElement("div");
    document.body.appendChild(this.popup);
    this._renderLayer();
  },

componentDidUpdate: function componentDidUpdate() {
    this._renderLayer();
  },

componentWillUnmount: function componentWillUnmount() {
    ReactDOM.unmountComponentAtNode(this.popup);
    document.body.removeChild(this.popup);
  },

_renderLayer: function _renderLayer() {
    ReactDOM.render(this.props.children, this.popup);
  },

render: function render() {
    // Render a placeholder
    return null;
  }

});

module.exports = RenderInBody;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 126 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function triggerJs(moduleName, shouldUpdate, moduleId) {

var triggerInformation = {
        type: 'jstrigger',
        moduleName: moduleName,
        shouldUpdate: shouldUpdate,
        moduleId: moduleId
    },
        jsonData = JSON.stringify(triggerInformation);
    document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
};

/***/ }),
/* 127 */
/***/ (function(module, exports) {

module.exports = {};

/***/ }),
/* 128 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.14 / 15.2.3.14 Object.keys(O)
var $keys = __webpack_require__(394);
var enumBugKeys = __webpack_require__(248);

module.exports = Object.keys || function keys(O) {
  return $keys(O, enumBugKeys);
};

/***/ }),
/* 129 */
/***/ (function(module, exports) {

module.exports = function (bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value: value
  };
};

/***/ }),
/* 130 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var keys = __webpack_require__(462);
var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';

var toStr = Object.prototype.toString;
var concat = Array.prototype.concat;
var origDefineProperty = Object.defineProperty;

var isFunction = function (fn) {
	return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
};

defineProperties.supportsDescriptors = !!supportsDescriptors;

module.exports = defineProperties;

/***/ }),
/* 131 */
/***/ (function(module, exports, __webpack_require__) {

var emptyObject = {};

if (process.env.NODE_ENV !== 'production') {
  Object.freeze(emptyObject);
}

module.exports = emptyObject;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 132 */
/***/ (function(module, exports) {

/**
 * The base implementation of `_.unary` without support for storing metadata.
 *
 * @private
 * @param {Function} func The function to cap arguments for.
 * @returns {Function} Returns the new capped function.
 */
function baseUnary(func) {
  return function(value) {
    return func(value);
  };
}

module.exports = baseUnary;

/***/ }),
/* 133 */
/***/ (function(module, exports, __webpack_require__) {

var DataView = __webpack_require__(965),
    Map = __webpack_require__(272),
    Promise = __webpack_require__(967),
    Set = __webpack_require__(420),
    WeakMap = __webpack_require__(422),
    baseGetTag = __webpack_require__(84),
    toSource = __webpack_require__(453);

/** `Object#toString` result references. */
var mapTag = '[object Map]',
    objectTag = '[object Object]',
    promiseTag = '[object Promise]',
    setTag = '[object Set]',
    weakMapTag = '[object WeakMap]';

var dataViewTag = '[object DataView]';

/** Used to detect maps, sets, and weakmaps. */
var dataViewCtorString = toSource(DataView),
    mapCtorString = toSource(Map),
    promiseCtorString = toSource(Promise),
    setCtorString = toSource(Set),
    weakMapCtorString = toSource(WeakMap);

/**
 * Gets the `toStringTag` of `value`.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */
var getTag = baseGetTag;

// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
    (Map && getTag(new Map) != mapTag) ||
    (Promise && getTag(Promise.resolve()) != promiseTag) ||
    (Set && getTag(new Set) != setTag) ||
    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
  getTag = function(value) {
    var result = baseGetTag(value),
        Ctor = result == objectTag ? value.constructor : undefined,
        ctorString = Ctor ? toSource(Ctor) : '';

if (ctorString) {
      switch (ctorString) {
        case dataViewCtorString: return dataViewTag;
        case mapCtorString: return mapTag;
        case promiseCtorString: return promiseTag;
        case setCtorString: return setTag;
        case weakMapCtorString: return weakMapTag;
      }
    }
    return result;
  };
}

module.exports = getTag;

/***/ }),
/* 134 */
/***/ (function(module, exports) {

/** Used for built-in method references. */
var objectProto = Object.prototype;

/**
 * Checks if `value` is likely a prototype object.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
 */
function isPrototype(value) {
  var Ctor = value && value.constructor,
      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

return value === proto;
}

module.exports = isPrototype;

/***/ }),
/* 135 */
/***/ (function(module, exports, __webpack_require__) {

var isSymbol = __webpack_require__(183);

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;

/**
 * Converts `value` to a string key if it's not a string or symbol.
 *
 * @private
 * @param {*} value The value to inspect.
 * @returns {string|symbol} Returns the key.
 */
function toKey(value) {
  if (typeof value == 'string' || isSymbol(value)) {
    return value;
  }
  var result = (value + '');
  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
}

module.exports = toKey;

/***/ }),
/* 136 */
/***/ (function(module, exports) {

/**
 * Performs a
 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * comparison between two values to determine if they are equivalent.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 *
 * var object = { 'a': 1 };
 * var other = { 'a': 1 };
 *
 * _.eq(object, object);
 * // => true
 *
 * _.eq(object, other);
 * // => false
 *
 * _.eq('a', 'a');
 * // => true
 *
 * _.eq('a', Object('a'));
 * // => false
 *
 * _.eq(NaN, NaN);
 * // => true
 */
function eq(value, other) {
  return value === other || (value !== value && other !== other);
}

module.exports = eq;

/***/ }),
/* 137 */
/***/ (function(module, exports, __webpack_require__) {

var baseToString = __webpack_require__(998);

/**
 * Converts `value` to a string. An empty string is returned for `null`
 * and `undefined` values. The sign of `-0` is preserved.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 * @example
 *
 * _.toString(null);
 * // => ''
 *
 * _.toString(-0);
 * // => '-0'
 *
 * _.toString([1, 2, 3]);
 * // => '1,2,3'
 */
function toString(value) {
  return value == null ? '' : baseToString(value);
}

module.exports = toString;

/***/ }),
/* 138 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

/* harmony default export */ __webpack_exports__["a"] = (omit);

/***/ }),
/* 139 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_util_es_unsafeLifecyclesPolyfill__ = __webpack_require__(1166);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__ = __webpack_require__(1128);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__AnimateChild__ = __webpack_require__(1127);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__util_animate__ = __webpack_require__(467);

var defaultKey = 'rc_animate_' + Date.now();

function noop() {}

var Animate = function (_React$Component) {
  __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Animate, _React$Component);

// eslint-disable-line

function Animate(props) {
    __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Animate);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Animate.__proto__ || Object.getPrototypeOf(Animate)).call(this, props));

_initialiseProps.call(_this);

_this.currentlyAnimatingKeys = {};
    _this.keysToEnter = [];
    _this.keysToLeave = [];

_this.state = {
      children: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["a" /* toArrayChildren */])(getChildrenFromProps(props))
    };

_this.childrenRefs = {};
    return _this;
  }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Animate, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      var _this2 = this;

this.nextProps = nextProps;
      var nextChildren = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["a" /* toArrayChildren */])(getChildrenFromProps(nextProps));
      var props = this.props;
      // exclusive needs immediate response
      if (props.exclusive) {
        Object.keys(this.currentlyAnimatingKeys).forEach(function (key) {
          _this3.stop(key);
        });
      }
      var showProp = props.showProp;
      var currentlyAnimatingKeys = this.currentlyAnimatingKeys;
      // last props children if exclusive
      var currentChildren = props.exclusive ? __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["a" /* toArrayChildren */])(getChildrenFromProps(props)) : this.state.children;
      // in case destroy in showProp mode
      var newChildren = [];
      if (showProp) {
        currentChildren.forEach(function (currentChild) {
          var nextChild = currentChild && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["b" /* findChildInChildrenByKey */])(nextChildren, currentChild.key);
          var newChild = void 0;
          if ((!nextChild || !nextChild.props[showProp]) && currentChild.props[showProp]) {
            newChild = __WEBPACK_IMPORTED_MODULE_6_react___default.a.cloneElement(nextChild || currentChild, __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()({}, showProp, true));
          } else {
            newChild = nextChild;
          }
          if (newChild) {
            newChildren.push(newChild);
          }
        });
        nextChildren.forEach(function (nextChild) {
          if (!nextChild || !__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["b" /* findChildInChildrenByKey */])(currentChildren, nextChild.key)) {
            newChildren.push(nextChild);
          }
        });
      } else {
        newChildren = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["c" /* mergeChildren */])(currentChildren, nextChildren);
      }

// need render to avoid update
      this.setState({
        children: newChildren
      });

nextChildren.forEach(function (child) {
        var key = child && child.key;
        if (child && currentlyAnimatingKeys[key]) {
          return;
        }
        var hasPrev = child && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["b" /* findChildInChildrenByKey */])(currentChildren, key);
        if (showProp) {
          var showInNext = child.props[showProp];
          if (hasPrev) {
            var showInNow = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["d" /* findShownChildInChildrenByKey */])(currentChildren, key, showProp);
            if (!showInNow && showInNext) {
              _this3.keysToEnter.push(key);
            }
          } else if (showInNext) {
            _this3.keysToEnter.push(key);
          }
        } else if (!hasPrev) {
          _this3.keysToEnter.push(key);
        }
      });

currentChildren.forEach(function (child) {
        var key = child && child.key;
        if (child && currentlyAnimatingKeys[key]) {
          return;
        }
        var hasNext = child && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["b" /* findChildInChildrenByKey */])(nextChildren, key);
        if (showProp) {
          var showInNow = child.props[showProp];
          if (hasNext) {
            var showInNext = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["d" /* findShownChildInChildrenByKey */])(nextChildren, key, showProp);
            if (!showInNext && showInNow) {
              _this3.keysToLeave.push(key);
            }
          } else if (showInNow) {
            _this3.keysToLeave.push(key);
          }
        } else if (!hasNext) {
          _this3.keysToLeave.push(key);
        }
      });
    }
  }, {
    key: 'componentDidUpdate',
    value: function componentDidUpdate() {
      var keysToEnter = this.keysToEnter;
      this.keysToEnter = [];
      keysToEnter.forEach(this.performEnter);
      var keysToLeave = this.keysToLeave;
      this.keysToLeave = [];
      keysToLeave.forEach(this.performLeave);
    }
  }, {
    key: 'isValidChildByKey',
    value: function isValidChildByKey(currentChildren, key) {
      var showProp = this.props.showProp;
      if (showProp) {
        return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["d" /* findShownChildInChildrenByKey */])(currentChildren, key, showProp);
      }
      return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["b" /* findChildInChildrenByKey */])(currentChildren, key);
    }
  }, {
    key: 'stop',
    value: function stop(key) {
      delete this.currentlyAnimatingKeys[key];
      var component = this.childrenRefs[key];
      if (component) {
        component.stop();
      }
    }
  }, {
    key: 'render',
    value: function render() {
      var _this4 = this;

return Animate;
}(__WEBPACK_IMPORTED_MODULE_6_react___default.a.Component);

Animate.isAnimate = true;
Animate.propTypes = {
  className: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string,
  style: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.object,
  component: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.any,
  componentProps: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.object,
  animation: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.object,
  transitionName: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.object]),
  transitionEnter: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.bool,
  transitionAppear: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.bool,
  exclusive: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.bool,
  transitionLeave: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.bool,
  onEnd: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func,
  onEnter: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func,
  onLeave: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func,
  onAppear: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func,
  showProp: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string,
  children: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.node
};
Animate.defaultProps = {
  animation: {},
  component: 'span',
  componentProps: {},
  transitionEnter: true,
  transitionLeave: true,
  transitionAppear: false,
  onEnd: noop,
  onEnter: noop,
  onLeave: noop,
  onAppear: noop
};

var _initialiseProps = function _initialiseProps() {
  var _this5 = this;

this.performEnter = function (key) {
    // may already remove by exclusive
    if (_this5.childrenRefs[key]) {
      _this5.currentlyAnimatingKeys[key] = true;
      _this5.childrenRefs[key].componentWillEnter(_this5.handleDoneAdding.bind(_this5, key, 'enter'));
    }
  };

this.performAppear = function (key) {
    if (_this5.childrenRefs[key]) {
      _this5.currentlyAnimatingKeys[key] = true;
      _this5.childrenRefs[key].componentWillAppear(_this5.handleDoneAdding.bind(_this5, key, 'appear'));
    }
  };

this.handleDoneAdding = function (key, type) {
    var props = _this5.props;
    delete _this5.currentlyAnimatingKeys[key];
    // if update on exclusive mode, skip check
    if (props.exclusive && props !== _this5.nextProps) {
      return;
    }
    var currentChildren = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["a" /* toArrayChildren */])(getChildrenFromProps(props));
    if (!_this5.isValidChildByKey(currentChildren, key)) {
      // exclusive will not need this
      _this5.performLeave(key);
    } else if (type === 'appear') {
      if (__WEBPACK_IMPORTED_MODULE_11__util_animate__["a" /* default */].allowAppearCallback(props)) {
        props.onAppear(key);
        props.onEnd(key, true);
      }
    } else if (__WEBPACK_IMPORTED_MODULE_11__util_animate__["a" /* default */].allowEnterCallback(props)) {
      props.onEnter(key);
      props.onEnd(key, true);
    }
  };

this.performLeave = function (key) {
    // may already remove by exclusive
    if (_this5.childrenRefs[key]) {
      _this5.currentlyAnimatingKeys[key] = true;
      _this5.childrenRefs[key].componentWillLeave(_this5.handleDoneLeaving.bind(_this5, key));
    }
  };

this.handleDoneLeaving = function (key) {
    var props = _this5.props;
    delete _this5.currentlyAnimatingKeys[key];
    // if update on exclusive mode, skip check
    if (props.exclusive && props !== _this5.nextProps) {
      return;
    }
    var currentChildren = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["a" /* toArrayChildren */])(getChildrenFromProps(props));
    // in case state change is too fast
    if (_this5.isValidChildByKey(currentChildren, key)) {
      _this5.performEnter(key);
    } else {
      var end = function end() {
        if (__WEBPACK_IMPORTED_MODULE_11__util_animate__["a" /* default */].allowLeaveCallback(props)) {
          props.onLeave(key);
          props.onEnd(key, false);
        }
      };
      if (!__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__ChildrenUtils__["e" /* isSameChildren */])(_this5.state.children, currentChildren, props.showProp)) {
        _this5.setState({
          children: currentChildren
        }, end);
      } else {
        end();
      }
    }
  };
};

/* harmony default export */ __webpack_exports__["a"] = (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8_rc_util_es_unsafeLifecyclesPolyfill__["a" /* default */])(Animate));

/***/ }),
/* 140 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Menu__ = __webpack_require__(1143);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__SubMenu__ = __webpack_require__(469);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__MenuItem__ = __webpack_require__(1144);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__MenuItemGroup__ = __webpack_require__(1145);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__Divider__ = __webpack_require__(1142);
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return __WEBPACK_IMPORTED_MODULE_1__SubMenu__["a"]; });
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return __WEBPACK_IMPORTED_MODULE_2__MenuItem__["a"]; });
/* unused harmony reexport MenuItem */
/* unused harmony reexport MenuItemGroup */
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return __WEBPACK_IMPORTED_MODULE_3__MenuItemGroup__["a"]; });
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return __WEBPACK_IMPORTED_MODULE_4__Divider__["a"]; });

/* harmony default export */ __webpack_exports__["c"] = (__WEBPACK_IMPORTED_MODULE_0__Menu__["a" /* default */]);

/***/ }),
/* 141 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = addEventListenerWrap;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_add_dom_event_listener__ = __webpack_require__(594);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_add_dom_event_listener___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_add_dom_event_listener__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);

function addEventListenerWrap(target, eventType, cb, option) {
  /* eslint camelcase: 2 */
  var callback = __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.unstable_batchedUpdates ? function run(e) {
    __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.unstable_batchedUpdates(cb, e);
  } : cb;
  return __WEBPACK_IMPORTED_MODULE_0_add_dom_event_listener___default()(target, eventType, callback, option);
}

/***/ }),
/* 142 */
/***/ (function(module, exports) {

/**
 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
 * of an array-like value.
 */
var MAX_SAFE_INTEGER = 9007199254740991;

/**
 * Checks if `value` is a valid array-like length.
 *
 * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
 */
function isLength(value) {
  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
}

module.exports = isLength;

/***/ }),
/* 143 */
/***/ (function(module, exports) {

/**
 * Checks if `value` is object-like.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 */
function isObjectLike(value) {
  return !!value && typeof value == 'object';
}

module.exports = isObjectLike;

/***/ }),
/* 144 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var EventPluginRegistry = __webpack_require__(193);
var EventPluginUtils = __webpack_require__(319);
var ReactErrorUtils = __webpack_require__(325);

var accumulateInto = __webpack_require__(537);
var forEachAccumulated = __webpack_require__(539);
var invariant = __webpack_require__(19);

/**
 * Internal store for event listeners
 */
var listenerBank = {};

/**
 * Internal queue of events that have accumulated their dispatches and are
 * waiting to have their dispatches executed.
 */
var eventQueue = null;

/**
 * Dispatches an event and releases it back into the pool, unless persistent.
 *
 * @param {?object} event Synthetic event to be dispatched.
 * @param {boolean} simulated If the event is simulated (changes exn behavior)
 * @private
 */
var executeDispatchesAndRelease = function (event, simulated) {
  if (event) {
    EventPluginUtils.executeDispatchesInOrder(event, simulated);

if (!event.isPersistent()) {
      event.constructor.release(event);
    }
  }
};
var executeDispatchesAndReleaseSimulated = function (e) {
  return executeDispatchesAndRelease(e, true);
};
var executeDispatchesAndReleaseTopLevel = function (e) {
  return executeDispatchesAndRelease(e, false);
};

var getDictionaryKey = function (inst) {
  // Prevents V8 performance issue:
  // https://github.com/facebook/react/pull/7232
  return '.' + inst._rootNodeID;
};

/**
 * This is a unified interface for event plugins to be installed and configured.
 *
 * Event plugins can implement the following properties:
 *
 *   `extractEvents` {function(string, DOMEventTarget, string, object): *}
 *     Required. When a top-level event is fired, this method is expected to
 *     extract synthetic events that will in turn be queued and dispatched.
 *
 *   `eventTypes` {object}
 *     Optional, plugins that fire events must publish a mapping of registration
 *     names that are used to register listeners. Values of this mapping must
 *     be objects that contain `registrationName` or `phasedRegistrationNames`.
 *
 *   `executeDispatch` {function(object, function, string)}
 *     Optional, allows plugins to override how an event gets dispatched. By
 *     default, the listener is simply invoked.
 *
 * Each plugin that is injected into `EventsPluginHub` is immediately operable.
 *
 * @public
 */
var EventPluginHub = {

/**
   * Methods for injecting dependencies.
   */
  injection: {

/**
     * @param {array} InjectedEventPluginOrder
     * @public
     */
    injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,

/**
     * @param {object} injectedNamesToPlugins Map from names to plugin modules.
     */
    injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName

/**
   * Stores `listener` at `listenerBank[registrationName][key]`. Is idempotent.
   *
   * @param {object} inst The instance, which is the source of events.
   * @param {string} registrationName Name of listener (e.g. `onClick`).
   * @param {function} listener The callback to store.
   */
  putListener: function (inst, registrationName, listener) {
    !(typeof listener === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected %s listener to be a function, instead got type %s', registrationName, typeof listener) : _prodInvariant('94', registrationName, typeof listener) : void 0;

var key = getDictionaryKey(inst);
    var bankForRegistrationName = listenerBank[registrationName] || (listenerBank[registrationName] = {});
    bankForRegistrationName[key] = listener;

var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
    if (PluginModule && PluginModule.didPutListener) {
      PluginModule.didPutListener(inst, registrationName, listener);
    }
  },

/**
   * @param {object} inst The instance, which is the source of events.
   * @param {string} registrationName Name of listener (e.g. `onClick`).
   * @return {?function} The stored callback.
   */
  getListener: function (inst, registrationName) {
    var bankForRegistrationName = listenerBank[registrationName];
    var key = getDictionaryKey(inst);
    return bankForRegistrationName && bankForRegistrationName[key];
  },

/**
   * Deletes a listener from the registration bank.
   *
   * @param {object} inst The instance, which is the source of events.
   * @param {string} registrationName Name of listener (e.g. `onClick`).
   */
  deleteListener: function (inst, registrationName) {
    var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
    if (PluginModule && PluginModule.willDeleteListener) {
      PluginModule.willDeleteListener(inst, registrationName);
    }

var bankForRegistrationName = listenerBank[registrationName];
    // TODO: This should never be null -- when is it?
    if (bankForRegistrationName) {
      var key = getDictionaryKey(inst);
      delete bankForRegistrationName[key];
    }
  },

/**
   * Deletes all listeners for the DOM element with the supplied ID.
   *
   * @param {object} inst The instance, which is the source of events.
   */
  deleteAllListeners: function (inst) {
    var key = getDictionaryKey(inst);
    for (var registrationName in listenerBank) {
      if (!listenerBank.hasOwnProperty(registrationName)) {
        continue;
      }

if (!listenerBank[registrationName][key]) {
        continue;
      }

var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
      if (PluginModule && PluginModule.willDeleteListener) {
        PluginModule.willDeleteListener(inst, registrationName);
      }

delete listenerBank[registrationName][key];
    }
  },

/**
   * Allows registered plugins an opportunity to extract events from top-level
   * native browser events.
   *
   * @return {*} An accumulation of synthetic events.
   * @internal
   */
  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
    var events;
    var plugins = EventPluginRegistry.plugins;
    for (var i = 0; i < plugins.length; i++) {
      // Not every plugin in the ordering may be loaded at runtime.
      var possiblePlugin = plugins[i];
      if (possiblePlugin) {
        var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
        if (extractedEvents) {
          events = accumulateInto(events, extractedEvents);
        }
      }
    }
    return events;
  },

/**
   * Enqueues a synthetic event that should be dispatched when
   * `processEventQueue` is invoked.
   *
   * @param {*} events An accumulation of synthetic events.
   * @internal
   */
  enqueueEvents: function (events) {
    if (events) {
      eventQueue = accumulateInto(eventQueue, events);
    }
  },

/**
   * Dispatches all synthetic events on the event queue.
   *
   * @internal
   */
  processEventQueue: function (simulated) {
    // Set `eventQueue` to null before processing it so that we can tell if more
    // events get enqueued while processing.
    var processingEventQueue = eventQueue;
    eventQueue = null;
    if (simulated) {
      forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);
    } else {
      forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
    }
    !!eventQueue ? process.env.NODE_ENV !== 'production' ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.') : _prodInvariant('95') : void 0;
    // This would be a good time to rethrow if any of the event handlers threw.
    ReactErrorUtils.rethrowCaughtError();
  },

/**
   * These are needed for tests only. Do not use!
   */
  __purge: function () {
    listenerBank = {};
  },

__getListenerBank: function () {
    return listenerBank;
  }

};

module.exports = EventPluginHub;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 145 */
/***/ (function(module, exports, __webpack_require__) {

var EventConstants = __webpack_require__(62);
var EventPluginHub = __webpack_require__(144);
var EventPluginUtils = __webpack_require__(319);

var accumulateInto = __webpack_require__(537);
var forEachAccumulated = __webpack_require__(539);
var warning = __webpack_require__(18);

var PropagationPhases = EventConstants.PropagationPhases;
var getListener = EventPluginHub.getListener;

/**
 * Some event types have a notion of different registration names for different
 * "phases" of propagation. This finds listeners by a given phase.
 */
function listenerAtPhase(inst, event, propagationPhase) {
  var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
  return getListener(inst, registrationName);
}

/**
 * Tags a `SyntheticEvent` with dispatched listeners. Creating this function
 * here, allows us to not have to bind or create functions for each event.
 * Mutating the event's members allows us to not have to create a wrapping
 * "dispatch" object that pairs the event with the listener.
 */
function accumulateDirectionalDispatches(inst, upwards, event) {
  if (process.env.NODE_ENV !== 'production') {
    process.env.NODE_ENV !== 'production' ? warning(inst, 'Dispatching inst must not be null') : void 0;
  }
  var phase = upwards ? PropagationPhases.bubbled : PropagationPhases.captured;
  var listener = listenerAtPhase(inst, event, phase);
  if (listener) {
    event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
    event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
  }
}

/**
 * Collect dispatches (must be entirely collected before dispatching - see unit
 * tests). Lazily allocate the array to conserve memory.  We must loop through
 * each event and perform the traversal for each one. We cannot perform a
 * single traversal for the entire collection of events because each event may
 * have a different target.
 */
function accumulateTwoPhaseDispatchesSingle(event) {
  if (event && event.dispatchConfig.phasedRegistrationNames) {
    EventPluginUtils.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
  }
}

/**
 * Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
 */
function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
  if (event && event.dispatchConfig.phasedRegistrationNames) {
    var targetInst = event._targetInst;
    var parentInst = targetInst ? EventPluginUtils.getParentInstance(targetInst) : null;
    EventPluginUtils.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
  }
}

/**
 * Accumulates without regard to direction, does not look for phased
 * registration names. Same as `accumulateDirectDispatchesSingle` but without
 * requiring that the `dispatchMarker` be the same as the dispatched ID.
 */
function accumulateDispatches(inst, ignoredDirection, event) {
  if (event && event.dispatchConfig.registrationName) {
    var registrationName = event.dispatchConfig.registrationName;
    var listener = getListener(inst, registrationName);
    if (listener) {
      event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
      event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
    }
  }
}

/**
 * Accumulates dispatches on an `SyntheticEvent`, but only for the
 * `dispatchMarker`.
 * @param {SyntheticEvent} event
 */
function accumulateDirectDispatchesSingle(event) {
  if (event && event.dispatchConfig.registrationName) {
    accumulateDispatches(event._targetInst, null, event);
  }
}

function accumulateTwoPhaseDispatches(events) {
  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
}

function accumulateTwoPhaseDispatchesSkipTarget(events) {
  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
}

function accumulateEnterLeaveDispatches(leave, enter, from, to) {
  EventPluginUtils.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
}

function accumulateDirectDispatches(events) {
  forEachAccumulated(events, accumulateDirectDispatchesSingle);
}

/**
 * A small set of propagation patterns, each of which will accept a small amount
 * of information, and generate a set of "dispatch ready event objects" - which
 * are sets of events that have already been annotated with a set of dispatched
 * listener functions/ids. The API is designed this way to discourage these
 * propagation strategies from actually executing the dispatches, since we
 * always want to collect the entire set of dispatches before executing event a
 * single one.
 *
 * @constructor EventPropagators
 */
var EventPropagators = {
  accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
  accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
  accumulateDirectDispatches: accumulateDirectDispatches,
  accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
};

module.exports = EventPropagators;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 146 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * `ReactInstanceMap` maintains a mapping from a public facing stateful
 * instance (key) and the internal representation (value). This allows public
 * methods to accept the user facing instance as an argument and map them back
 * to internal methods.
 */

// TODO: Replace this with ES6: var ReactInstanceMap = new Map();

var ReactInstanceMap = {

/**
   * This API should be called `delete` but we'd have to make sure to always
   * transform these to strings for IE support. When this transform is fully
   * supported we can rename it.
   */
  remove: function (key) {
    key._reactInternalInstance = undefined;
  },

get: function (key) {
    return key._reactInternalInstance;
  },

has: function (key) {
    return key._reactInternalInstance !== undefined;
  },

set: function (key, value) {
    key._reactInternalInstance = value;
  }

};

module.exports = ReactInstanceMap;

/***/ }),
/* 147 */
/***/ (function(module, exports, __webpack_require__) {

var SyntheticEvent = __webpack_require__(64);

var getEventTarget = __webpack_require__(334);

/**
 * @interface UIEvent
 * @see http://www.w3.org/TR/DOM-Level-3-Events/
 */
var UIEventInterface = {
  view: function (event) {
    if (event.view) {
      return event.view;
    }

var target = getEventTarget(event);
    if (target.window === target) {
      // target is a window object
      return target;
    }

/**
 * @param {object} dispatchConfig Configuration used to dispatch this event.
 * @param {string} dispatchMarker Marker identifying the event target.
 * @param {object} nativeEvent Native browser event.
 * @extends {SyntheticEvent}
 */
function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}

SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface);

module.exports = SyntheticUIEvent;

/***/ }),
/* 148 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var invariant = __webpack_require__(19);

/**
 * `Transaction` creates a black box that is able to wrap any method such that
 * certain invariants are maintained before and after the method is invoked
 * (Even if an exception is thrown while invoking the wrapped method). Whoever
 * instantiates a transaction can provide enforcers of the invariants at
 * creation time. The `Transaction` class itself will supply one additional
 * automatic invariant for you - the invariant that any transaction instance
 * should not be run while it is already being run. You would typically create a
 * single instance of a `Transaction` for reuse multiple times, that potentially
 * is used to wrap several different methods. Wrappers are extremely simple -
 * they only require implementing two methods.
 *
 * <pre>
 *                       wrappers (injected at creation time)
 *                                      +        +
 *                                      |        |
 *                    +-----------------|--------|--------------+
 *                    |                 v        |              |
 *                    |      +---------------+   |              |
 *                    |   +--|    wrapper1   |---|----+         |
 *                    |   |  +---------------+   v    |         |
 *                    |   |          +-------------+  |         |
 *                    |   |     +----|   wrapper2  |--------+   |
 *                    |   |     |    +-------------+  |     |   |
 *                    |   |     |                     |     |   |
 *                    |   v     v                     v     v   | wrapper
 *                    | +---+ +---+   +---------+   +---+ +---+ | invariants
 * perform(anyMethod) | |   | |   |   |         |   |   | |   | | maintained
 * +----------------->|-|---|-|---|-->|anyMethod|---|---|-|---|-|-------->
 *                    | |   | |   |   |         |   |   | |   | |
 *                    | |   | |   |   |         |   |   | |   | |
 *                    | |   | |   |   |         |   |   | |   | |
 *                    | +---+ +---+   +---------+   +---+ +---+ |
 *                    |  initialize                    close    |
 *                    +-----------------------------------------+
 * </pre>
 *
 * Use cases:
 * - Preserving the input selection ranges before/after reconciliation.
 *   Restoring selection even in the event of an unexpected error.
 * - Deactivating events while rearranging the DOM, preventing blurs/focuses,
 *   while guaranteeing that afterwards, the event system is reactivated.
 * - Flushing a queue of collected DOM mutations to the main UI thread after a
 *   reconciliation takes place in a worker thread.
 * - Invoking any collected `componentDidUpdate` callbacks after rendering new
 *   content.
 * - (Future use case): Wrapping particular flushes of the `ReactWorker` queue
 *   to preserve the `scrollTop` (an automatic scroll aware DOM).
 * - (Future use case): Layout calculations before and after DOM updates.
 *
 * Transactional plugin API:
 * - A module that has an `initialize` method that returns any precomputation.
 * - and a `close` method that accepts the precomputation. `close` is invoked
 *   when the wrapped process is completed, or has failed.
 *
 * @param {Array<TransactionalWrapper>} transactionWrapper Wrapper modules
 * that implement `initialize` and `close`.
 * @return {Transaction} Single transaction for reuse in thread.
 *
 * @class Transaction
 */
var Mixin = {
  /**
   * Sets up this instance so that it is prepared for collecting metrics. Does
   * so such that this setup method may be used on an instance that is already
   * initialized, in a way that does not consume additional memory upon reuse.
   * That can be useful if you decide to make your subclass of this mixin a
   * "PooledClass".
   */
  reinitializeTransaction: function () {
    this.transactionWrappers = this.getTransactionWrappers();
    if (this.wrapperInitData) {
      this.wrapperInitData.length = 0;
    } else {
      this.wrapperInitData = [];
    }
    this._isInTransaction = false;
  },

_isInTransaction: false,

/**
   * @abstract
   * @return {Array<TransactionWrapper>} Array of transaction wrappers.
   */
  getTransactionWrappers: null,

isInTransaction: function () {
    return !!this._isInTransaction;
  },

/**
   * Executes the function within a safety window. Use this for the top level
   * methods that result in large amounts of computation/mutations that would
   * need to be safety checked. The optional arguments helps prevent the need
   * to bind in many cases.
   *
   * @param {function} method Member of scope to call.
   * @param {Object} scope Scope to invoke from.
   * @param {Object?=} a Argument to pass to the method.
   * @param {Object?=} b Argument to pass to the method.
   * @param {Object?=} c Argument to pass to the method.
   * @param {Object?=} d Argument to pass to the method.
   * @param {Object?=} e Argument to pass to the method.
   * @param {Object?=} f Argument to pass to the method.
   *
   * @return {*} Return value from `method`.
   */
  perform: function (method, scope, a, b, c, d, e, f) {
    !!this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.perform(...): Cannot initialize a transaction when there is already an outstanding transaction.') : _prodInvariant('27') : void 0;
    var errorThrown;
    var ret;
    try {
      this._isInTransaction = true;
      // Catching errors makes debugging more difficult, so we start with
      // errorThrown set to true before setting it to false after calling
      // close -- if it's still set to true in the finally block, it means
      // one of these calls threw.
      errorThrown = true;
      this.initializeAll(0);
      ret = method.call(scope, a, b, c, d, e, f);
      errorThrown = false;
    } finally {
      try {
        if (errorThrown) {
          // If `method` throws, prefer to show that stack trace over any thrown
          // by invoking `closeAll`.
          try {
            this.closeAll(0);
          } catch (err) {}
        } else {
          // Since `method` didn't throw, we don't want to silence the exception
          // here.
          this.closeAll(0);
        }
      } finally {
        this._isInTransaction = false;
      }
    }
    return ret;
  },

initializeAll: function (startIndex) {
    var transactionWrappers = this.transactionWrappers;
    for (var i = startIndex; i < transactionWrappers.length; i++) {
      var wrapper = transactionWrappers[i];
      try {
        // Catching errors makes debugging more difficult, so we start with the
        // OBSERVED_ERROR state before overwriting it with the real return value
        // of initialize -- if it's still set to OBSERVED_ERROR in the finally
        // block, it means wrapper.initialize threw.
        this.wrapperInitData[i] = Transaction.OBSERVED_ERROR;
        this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null;
      } finally {
        if (this.wrapperInitData[i] === Transaction.OBSERVED_ERROR) {
          // The initializer for wrapper i threw an error; initialize the
          // remaining wrappers but silence any exceptions from them to ensure
          // that the first error is the one to bubble up.
          try {
            this.initializeAll(i + 1);
          } catch (err) {}
        }
      }
    }
  },

/**
   * Invokes each of `this.transactionWrappers.close[i]` functions, passing into
   * them the respective return values of `this.transactionWrappers.init[i]`
   * (`close`rs that correspond to initializers that failed will not be
   * invoked).
   */
  closeAll: function (startIndex) {
    !this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.closeAll(): Cannot close transaction when none are open.') : _prodInvariant('28') : void 0;
    var transactionWrappers = this.transactionWrappers;
    for (var i = startIndex; i < transactionWrappers.length; i++) {
      var wrapper = transactionWrappers[i];
      var initData = this.wrapperInitData[i];
      var errorThrown;
      try {
        // Catching errors makes debugging more difficult, so we start with
        // errorThrown set to true before setting it to false after calling
        // close -- if it's still set to true in the finally block, it means
        // wrapper.close threw.
        errorThrown = true;
        if (initData !== Transaction.OBSERVED_ERROR && wrapper.close) {
          wrapper.close.call(this, initData);
        }
        errorThrown = false;
      } finally {
        if (errorThrown) {
          // The closer for wrapper i threw an error; close the remaining
          // wrappers but silence any exceptions from them to ensure that the
          // first error is the one to bubble up.
          try {
            this.closeAll(i + 1);
          } catch (e) {}
        }
      }
    }
    this.wrapperInitData.length = 0;
  }
};

var Transaction = {

Mixin: Mixin,

/**
   * Token to look for to determine if an error occurred.
   */
  OBSERVED_ERROR: {}

};

module.exports = Transaction;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 149 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__button__ = __webpack_require__(603);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__button_group__ = __webpack_require__(602);

__WEBPACK_IMPORTED_MODULE_0__button__["a" /* default */].Group = __WEBPACK_IMPORTED_MODULE_1__button_group__["a" /* default */];
/* harmony default export */ __webpack_exports__["default"] = (__WEBPACK_IMPORTED_MODULE_0__button__["a" /* default */]);

/***/ }),
/* 150 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _inputNumber = __webpack_require__(611);

var _inputNumber2 = _interopRequireDefault(_inputNumber);

var _select = __webpack_require__(65);

var _select2 = _interopRequireDefault(_select);

var _input = __webpack_require__(77);

var _input2 = _interopRequireDefault(_input);

__webpack_require__(612);

__webpack_require__(66);

__webpack_require__(78);

__webpack_require__(893);

var _EditorHelpers = __webpack_require__(26);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var InputGroup = _input2.default.Group;
var Option = _select2.default.Option;

var BeNumber = function (_React$Component) {
    _inherits(BeNumber, _React$Component);

function BeNumber(props) {
        _classCallCheck(this, BeNumber);

var _this = _possibleConstructorReturn(this, (BeNumber.__proto__ || Object.getPrototypeOf(BeNumber)).call(this, props));

_this.options = null;
        _this.optionsType = null;
        _this.unitDropDown = null;
        _this.state = {
            value: '',
            unit: ''
        };
        _this.processOptions = _this.processOptions.bind(_this);
        _this.onNumberChange = _this.onNumberChange.bind(_this);
        _this.onUnitChange = _this.onUnitChange.bind(_this);
        _this.getUnitFromValueOrOptions = _this.getUnitFromValueOrOptions.bind(_this);
        _this.blurHandler = _this.blurHandler.bind(_this);
        _this.getOptionVal = _this.getOptionVal.bind(_this);
        _this.getOptionDefault = _this.getOptionDefault.bind(_this);
        return _this;
    }

_createClass(BeNumber, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            this.processOptions(this.props.options);
            if (this.validateValue(this.props.value)) {
                //unset case
                if ('' === this.props.value && this.props.resetPossible) {
                    this.setState({
                        unit: this.getOptionVal('unit')
                    });
                } else {
                    var valueAndUnit = (0, _EditorHelpers.getValueAndUnit)(this.props.value);
                    this.setState({
                        value: valueAndUnit.value || 0,
                        unit: this.getUnitFromValueOrOptions(valueAndUnit)
                    });
                }
            }
        }
    }, {
        key: 'buildUnitDropDown',
        value: function buildUnitDropDown() {
            if ('object' == this.optionsType) {
                if (this.options.unit) {
                    if (typeof this.options.unit === 'string') {
                        this.unitDropDown = this.getSingleUnit([this.options.unit]);
                    } else if (1 < this.options.unit.length) {
                        this.unitDropDown = this.getUnitList(this.options.unit);
                    } else if (this.options.unit.length === 1) {
                        this.unitDropDown = this.getSingleUnit(this.options.unit);
                    }
                }
            } else {
                if (this.options.get('unit')) {
                    if (typeof this.options.get('unit') === 'string') {
                        this.unitDropDown = this.getSingleUnit([this.options.get('unit')]);
                    } else if (1 < this.options.get('unit').size) {
                        this.unitDropDown = this.getUnitList(this.options.get('unit'));
                    } else if (this.options.get('unit').size === 1) {
                        this.unitDropDown = this.getSingleUnit(this.options.get('unit'));
                    }
                }
            }
        }
    }, {
        key: 'processOptions',
        value: function processOptions(options) {
            if (this.validateOptions(options)) {
                this.options = options;
                if ((0, _EditorHelpers.isImmutable)(options)) {
                    this.optionsType = 'immutable';
                } else if ('[object Object]' == (0, _EditorHelpers.getObjectType)(options)) {
                    this.optionsType = 'object';
                }
            }
        }
    }, {
        key: 'getOptionVal',
        value: function getOptionVal(option) {
            if ('object' == this.optionsType) {
                var val = this.options[option];
                if (this.options.hasOwnProperty(option)) {
                    if ('unit' == option) {
                        if ('[object Array]' == (0, _EditorHelpers.getObjectType)(val)) {
                            return val[0];
                        } else if ('string' == (0, _EditorHelpers.getObjectType)(val)) {
                            return val;
                        } else {
                            return this.getOptionDefault(option);
                        }
                    } else if (!isNaN(val) && val !== '') {
                        return parseFloat(val);
                    } else {
                        return this.getOptionDefault(option);
                    }
                } else {
                    if ('min' === option) {
                        return -Infinity;
                    } else if ('max' === option) {
                        return Infinity;
                    } else {
                        return null;
                    }
                }
            } else if ('immutable' == this.optionsType) {
                var _val = this.options.get(option);
                if (this.options.has(option)) {
                    if ('unit' == option) {
                        if ((0, _EditorHelpers.isImmutable)(_val)) {
                            return _val.get(0);
                        } else if ('string' === typeof _val) {
                            return _val;
                        } else {
                            return this.getOptionDefault(option);
                        }
                    } else if (!isNaN(_val)) {
                        return parseFloat(_val);
                    } else {
                        return this.getOptionDefault(option);
                    }
                } else {
                    if ('min' === option) {
                        return -Infinity;
                    } else if ('max' === option) {
                        return Infinity;
                    } else {
                        return null;
                    }
                }
            }
            return null;
        }
    }, {
        key: 'getOptionDefault',
        value: function getOptionDefault(option) {
            switch (option) {
                case 'min':
                    return -Infinity;
                case 'max':
                    return Infinity;
                case 'step':
                    return 1;
                case 'unit':
                    return '';
                default:
                    return -1;
            }
        }
    }, {
        key: 'getUnitFromValueOrOptions',
        value: function getUnitFromValueOrOptions(valueAndUnit) {
            return valueAndUnit.unit || (this.options ? this.getOptionVal('unit') : '');
        }
    }, {
        key: 'validateOptions',
        value: function validateOptions(options) {
            if ((0, _EditorHelpers.isValidDataStructure)(options) && (0, _EditorHelpers.validateValues)(options, true, true, true)) {
                return true;
            }
            return false;
        }
    }, {
        key: 'validateValue',
        value: function validateValue(value) {
            //unset case
            if ('' === value && this.props.resetPossible) {
                return true;
            }
            var floatValue = parseFloat(value),
                min = this.getOptionVal('min'),
                max = this.getOptionVal('max');

if (isNaN(min) || isNaN(max)) {
                return true;
            }

return !isNaN(floatValue) ? this.options ? min <= floatValue && max >= floatValue : true : false;
        }
    }, {
        key: 'shouldAddUnit',
        value: function shouldAddUnit(value, unit) {
            var finalValue = '';
            if ('object' === this.optionsType) {
                if (this.options.add_unit_to_value || this.options.unit && typeof this.options.unit !== 'string') {
                    finalValue = value + unit;
                } else {
                    finalValue = value;
                }
            } else {
                if (this.options.get('add_unit_to_value') || this.options.get('unit') && typeof this.options.get('unit') !== 'string') {
                    finalValue = value + unit;
                } else {
                    finalValue = value;
                }
            }

return finalValue;
        }
    }, {
        key: 'onNumberChange',
        value: function onNumberChange(value) {
            if ('undefined' == typeof value) {
                return;
            } else if ("string" == typeof value) {
                //unset value
                if ('' === value && this.props.resetPossible) {
                    this.setState({ value: value });
                    this.props.onChange(value);
                }
                return;
            } else {
                var min = this.getOptionVal('min'),
                    max = this.getOptionVal('max');

var tempValue = this.shouldAddUnit(value, this.state.unit);

if (this.props.isAjax) {
                    if ((!isNaN(min) ? value >= min : true) && (!isNaN(max) ? value <= max : true)) {
                        this.setState({
                            value: value
                        });
                        (0, _EditorHelpers.debounce)(this.props.onChange, 700, tempValue);
                    }
                } else {
                    if ((!isNaN(min) ? value >= min : true) && (!isNaN(max) ? value <= max : true)) {
                        //comment this setState
                        // this.setState({
                        //     value : value
                        // });
                        this.props.onChange(tempValue);
                    }
                }
            }
        }
    }, {
        key: 'onUnitChange',
        value: function onUnitChange(unit) {
            //comment this setState
            // this.setState({
            //     unit : unit
            // });
            this.props.onChange(this.state.value + unit);
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            if (this.props.value != nextProps.value) {
                if ('' === nextProps.value && this.props.resetPossible) {
                    this.setState({ value: '' });
                } else {
                    var valueAndUnit = (0, _EditorHelpers.getValueAndUnit)(nextProps.value);
                    this.setState({
                        value: valueAndUnit.value || 0,
                        unit: this.getUnitFromValueOrOptions(valueAndUnit)
                    });
                }
            }
        }
    }, {
        key: 'getUnitList',
        value: function getUnitList(unit) {
            return React.createElement(
                _select2.default,
                { disabled: '' === this.state.value && this.props.resetPossible, dropdownClassName: 'be-number-input-dropdown', showArrow: false, defaultValue: this.state.unit || unit[0], value: this.state.unit || unit[0], onChange: this.onUnitChange, getPopupContainer: function getPopupContainer(triggerNode) {
                        return triggerNode.parentNode;
                    } },
                unit.map(function (unit) {
                    return React.createElement(
                        Option,
                        { key: unit, value: unit },
                        unit
                    );
                })
            );
        }
    }, {
        key: 'getSingleUnit',
        value: function getSingleUnit(unit) {
            return React.createElement(
                'div',
                { className: "be-number-input-single-unit" + ('' === this.state.value && this.props.resetPossible ? " disabled" : "") },
                unit.get ? unit.get(0) : unit[0]
            );
        }
    }, {
        key: 'blurHandler',
        value: function blurHandler(e) {
            var min = this.getOptionVal('min'),
                max = this.getOptionVal('max'),
                value = e.target.value;
            if ('undefined' == typeof value) {
                return;
            } else if ('' === value && this.props.resetPossible) {
                return;
            } else if ('-' == value) {
                if (null != min) {
                    this.setState({
                        value: min
                    });
                } else {
                    this.setState({
                        value: '0'
                    });
                }
            } else if (null != min) {
                if (parseFloat(value) < min) {
                    this.setState({
                        value: min
                    });
                }
            } else if (null != max) {
                if (parseFloat(value) > max) {
                    this.setState({
                        value: max
                    });
                }
            }
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

this.buildUnitDropDown();
            return this.options ? React.createElement(
                'div',
                { className: (0, _EditorHelpers.getClassNames)("be-ui-component", "be-number-input", this.props.className) + (null === this.unitDropDown ? ' be-number-no-unit' : '') },
                React.createElement(
                    InputGroup,
                    { compact: true },
                    React.createElement(_inputNumber2.default, {
                        step: this.getOptionVal('step') || 1,
                        value: this.state.value,
                        onBlur: this.blurHandler,
                        formatter: function formatter(value) {
                            return '' === value || !isNaN(value) || '-' === value ? value : _this2.state.value;
                        },
                        onChange: this.onNumberChange
                    }),
                    this.unitDropDown
                )
            ) : null;
        }
    }]);

return BeNumber;
}(React.Component);

BeNumber.defaultProps = {
    resetPossible: true
};
exports.default = BeNumber;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 151 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, React, jQuery) {

var closeDrawer = __webpack_require__(2).closeDrawer,
    setSelection = __webpack_require__(2).setSelection,
    resetSelection = __webpack_require__(2).resetSelection,
    openDrawer = __webpack_require__(2).openDrawer,
    openContextMenu = __webpack_require__(2).openContextMenu,
    changeTargetDisplay = __webpack_require__(2).changeTargetDisplay,
    routeHandler = __webpack_require__(99),
    fitVideoToContainer = __webpack_require__(236),
    cssAnimateHelper = __webpack_require__(120),
    CssAnimate = __webpack_require__(688).CssAnimateCons,
    CssNewAnimate = __webpack_require__(124),
    triggerJs = __webpack_require__(126),
    encodePath = __webpack_require__(43).encodePath,
    getAttFromDisplay = __webpack_require__(123),
    Module = __webpack_require__(152),
    setDragPlaceholder = __webpack_require__(2).setDragPlaceholder,
    resetDragPlaceholder = __webpack_require__(2).resetDragPlaceholder,
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    DropTarget = __webpack_require__(37).DropTarget,
    getAttsBasedOnTargetDisplay = __webpack_require__(53),
    getModuleStyle = __webpack_require__(96),
    getConcatenatedCSS = __webpack_require__(67),
    findDOMNode = __webpack_require__(7).findDOMNode,
    checkIfSelected = __webpack_require__(80).checkIfSelected,
    parentComponentFinder = __webpack_require__(98),
    editAtt = __webpack_require__(2).editAtt,
    flow = __webpack_require__(60),
    store = __webpack_require__(11),
    add = __webpack_require__(2).add,
    columnLayoutToClassMapper = __webpack_require__(682),
    isEmpty = __webpack_require__(5),
    routeResolve = __webpack_require__(33),
    dndScope = __webpack_require__(79).moduleListDnDConstant;
var dropSpec = {
  hover: function hover(props, monitor, component) {

var hoveredColumnPath = props.path,
        hoveredModulePath,
        hoveredItemOffset = findDOMNode(component).getBoundingClientRect(),
        draggedItem = monitor.getItem(),
        draggedItemPath = draggedItem.draggedModulePath || Immutable.List(),
        draggedItemOffset = monitor.getClientOffset();

if (0 != props.column.get('inner').size) {
      return;
    } else if (4 < hoveredColumnPath.size && 15 > draggedItemOffset.y - hoveredItemOffset.top) {
      hoveredModulePath = hoveredColumnPath.pop();
      if (Immutable.is(hoveredModulePath.pop(), draggedItemPath.pop())) {
        if (1 != hoveredModulePath.get(hoveredModulePath.size - 1) - draggedItemPath.get(draggedItemPath.size - 1)) {
          store.dispatch(setDragPlaceholder(hoveredModulePath, 'top'));
        }
      } else {
        store.dispatch(setDragPlaceholder(hoveredModulePath, 'top'));
      }
    } else if (4 < hoveredColumnPath.size && 15 > hoveredItemOffset.bottom - draggedItemOffset.y) {
      hoveredModulePath = hoveredColumnPath.pop();
      if (Immutable.is(hoveredModulePath.pop(), draggedItemPath.pop())) {
        if (-1 != hoveredModulePath.get(hoveredModulePath.size - 1) - draggedItemPath.get(draggedItemPath.size - 1)) {
          store.dispatch(setDragPlaceholder(hoveredModulePath, 'bottom'));
        }
      } else {
        store.dispatch(setDragPlaceholder(hoveredModulePath, 'bottom'));
      }
    } else if (0 == props.column.get('inner').size && 'tatsu_inner_column' == props.column.get('name') && 'tatsu_inner_row' == draggedItem.name) {
      store.dispatch(resetDragPlaceholder());
      return;
    } else {
      store.dispatch(setDragPlaceholder(hoveredColumnPath, ''));
    }
  },

drop: function drop(props, monitor) {

if (!monitor.didDrop()) {
      var type = monitor.getItem().type;
      if ('moduleListCard' === type) {
        return {
          moduleName: monitor.getItem().name
        };
      } else if ('module' === type) {
        return {
          sourcePath: monitor.getItem().draggedModulePath,
          dropEffect: props.dropEffect
        };
      }
    }
  }

};

function collect(connect, monitor) {

return {
    connectDropTarget: connect.dropTarget(),
    canDrop: monitor.canDrop(),
    isOver: monitor.isOver()
  };
}

var HeaderColumn = React.createClass({
  displayName: 'HeaderColumn',

setBorder: null,
  animateObj: null,
  triggerJs: false,
  initialCssAnimationTriggered: false,
  triggerAnimation: false,
  triggerParallax: false,
  propTypes: {
    path: listChecker,
    column: mapChecker,
    connectDropTarget: React.PropTypes.func.isRequired,
    targetDisplay: React.PropTypes.string,
    pathFromSelectionState: listChecker,
    dropEffect: React.PropTypes.string,
    moduleOptions: mapChecker,
    parent: mapChecker,
    isOver: React.PropTypes.bool,
    canDrop: React.PropTypes.bool
  },

getInitialState: function getInitialState() {
    return {
      hovered: false,
      widthDragger: Immutable.Map({
        position: false,
        active: false
      })
    };
  },

showWidthDragger: function showWidthDragger(position) {
    var curWidthDragger = this.state.widthDragger;
    this.setState({
      widthDragger: curWidthDragger.set('position', position)
    });
  },

hideWidthDragger: function hideWidthDragger() {
    var curWidthDragger = this.state.widthDragger;
    if (!curWidthDragger.get('active')) {
      this.setState({
        widthDragger: curWidthDragger.set('position', false)
      });
    }
  },

handleColWidthDrag: function handleColWidthDrag(e) {
    var curPos = e.pageX,
        curPath = this.props.path,
        curActiveDragHandle = this.state.widthDragger.get('position'),
        colWidth = 'right' == curActiveDragHandle ? this.props.column.getIn(['atts', 'column_width']) : this.props.parent.getIn(['inner', curPath.last() - 1, 'atts', 'column_width']),
        curVal = parseFloat(getAttFromDisplay(colWidth, this.props.targetDisplay)),
        distance = Math.abs(curPos - this.prevCurPos),
        targetPath = 'right' == curActiveDragHandle ? curPath : curPath.slice(0, -1).push(curPath.last() - 1),
        updatedVal;
    if (!isNaN(curVal) && false !== this.rowWidth) {
      if (curPos < this.prevCurPos) {
        updatedVal = (this.rowWidth * (curVal / 100) - distance) / this.rowWidth * 100;
        updatedVal = Math.round(updatedVal * 10) / 10;
        updatedVal = 10 <= updatedVal ? updatedVal : 10;
        store.dispatch(editAtt(targetPath, 'column_width', updatedVal, this.props.moduleOptions, 1, true, this.props.targetDisplay));
      } else if (curPos > this.prevCurPos) {
        updatedVal = (this.rowWidth * (curVal / 100) + distance) / this.rowWidth * 100;
        updatedVal = Math.round(updatedVal * 10) / 10;
        updatedVal = 100 >= updatedVal ? updatedVal : 100;
        store.dispatch(editAtt(targetPath, 'column_width', updatedVal, this.props.moduleOptions, 1, true, this.props.targetDisplay));
      }
    }
    this.prevCurPos = curPos;
  },

resetColWidth: function resetColWidth(e) {
    var iframe = document.getElementById('tatsu-preview');
    if (null != iframe) {
      iframe.contentDocument.body.classList.remove('tatsu-prev-pointer-events');
      this.prevCurPos = -1;
      iframe.contentWindow.removeEventListener('mouseup', this.resetColWidth);
      iframe.contentWindow.removeEventListener('mousemove', this.handleColWidthDrag);
    }
    if (false !== this.rowWidth) {
      this.rowWidth = false;
    }
    this.props.resetCurDraggingCol();
    this.setState({
      widthDragger: Immutable.Map({
        position: false,
        active: false
      })
    });
  },

initColWidthDrag: function initColWidthDrag(cols, e) {
    e.stopPropagation();
    var iframe = document.getElementById('tatsu-preview'),
        curNode = findDOMNode(this),
        curWidthDragger = this.state.widthDragger;
    if (null != iframe) {
      iframe.contentDocument.body.classList.add('tatsu-prev-pointer-events');
      this.prevCurPos = e.pageX;
      iframe.contentWindow.addEventListener('mouseup', this.resetColWidth);
      iframe.contentWindow.addEventListener('mousemove', this.handleColWidthDrag);
      iframe.contentWindow.postMessage('hover_reset', '*');
    }
    if (null != curNode) {
      this.rowWidth = null != curNode.parentElement ? curNode.parentElement.offsetWidth : false;
    }
    if ('string' == typeof this.props.targetDisplay && 'd' !== this.props.targetDisplay.charAt(0)) {
      cols.pop();
    }
    this.setState({
      widthDragger: curWidthDragger.set('active', true)
    }, function () {
      this.props.setCurDraggingCol(cols);
    }.bind(this));
  },

componentWillMount: function componentWillMount() {

this.animateObj = new CssNewAnimate(this.props.column, false);
  },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

handleRightClick: function handleRightClick(event) {

if (-1 < document.body.className.indexOf("preview")) {
      return;
    }
    event.preventDefault();
    event.stopPropagation();
    var currentTop = event.clientY,
        currentLeft = event.clientX + (-1 < document.body.className.indexOf('mce-fullscreen') ? 0.3 * window.innerWidth : 300),
        path = this.props.path,
        name = this.props.column.get('name'),
        id = this.props.column.get('id'),
        clientRect = findDOMNode(this).getBoundingClientRect(),
        title = this.props.column.get('title');
    store.dispatch(openContextMenu(currentTop, currentLeft, path, name, title, id, clientRect));
  },

componentDidUpdate: function componentDidUpdate() {

cssAnimateHelper(this);
    this.animateObj.triggerAnimation(this.props.column);
    if ('1' === this.props.column.getIn(['atts', 'bg_video']) && ('' != this.props.column.getIn(['atts', 'bg_video_mp4_src']) || '' != this.props.column.getIn(['atts', 'bg_video_ogg_src']) || '' != this.props.column.getIn(['atts', 'bg_video_webm_src']))) {
      var bgVideoWrap = jQuery(this.refs.videoRef);
      fitVideoToContainer(bgVideoWrap);
    }
    if (this.triggerJs) {
      triggerJs('trigger_ready', true);
      this.triggerJs = false;
    }
    if (this.triggerParallax) {
      triggerJs('tatsu_column', true);
      this.triggerParallax = false;
    }
  },

componentDidMount: function componentDidMount() {

if ('1' === this.props.column.getIn(['atts', 'bg_video']) && ('' != this.props.column.getIn(['atts', 'bg_video_mp4_src']) || '' != this.props.column.getIn(['atts', 'bg_video_ogg_src']) || '' != this.props.column.getIn(['atts', 'bg_video_webm_src']))) {
      var bgVideoWrap = jQuery(this.refs.videoRef);
      fitVideoToContainer(bgVideoWrap);
    }
    this.animateObj.init(this.props.moduleOptions);
  },

mouseEnterHandler: function mouseEnterHandler(event) {

if (-1 < document.body.className.indexOf("preview")) {
      return;
    }
    if (curPath.size > 2 && this.props.builderMode === 'header_builder') {
      jQuery(currentDocument).find('#tatsu-observer', '#tatsu-selection-tooltip').addClass('higher-z-index');
    }

document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    if (!(isMultiSelected && selectionPath.contains(curPath) || Immutable.is(curPath, selectionPath))) {
      var title = this.props.moduleOptions.getIn([this.props.column.get('name'), 'title']) || this.props.column.get('name'),
          messageData = 'hover_set,' + this.props.column.get('id') + ',' + title;
      document.getElementById('tatsu-preview').contentWindow.postMessage(messageData, '*');
    }
  },

mouseLeaveHandler: function mouseLeaveHandler() {

var currentDocument = document.getElementById('tatsu-preview').contentDocument;

jQuery(currentDocument).find('#tatsu-observer').removeClass('higher-z-index');

if (-1 < document.body.className.indexOf("preview")) {
      return;
    }
    var parent = this.props.parent,
        isMultiSelected = Immutable.List.isList(this.props.pathFromSelectionState.get(0)),
        selectionPath = this.props.pathFromSelectionState,
        parentPath = this.props.path.pop();
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    if (parent && !(isMultiSelected && selectionPath.contains(parentPath) || Immutable.is(parentPath, selectionPath))) {
      var parentTitle = this.props.moduleOptions.getIn([parent.get('name'), 'title']) || 'Tatsu Section';
      document.getElementById('tatsu-preview').contentWindow.postMessage('hover_set,' + parent.get('id') + ',' + parentTitle, '*');
    }
  },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
    result = !(Immutable.is(this.props.pathFromSelectionState, nextProps.pathFromSelectionState) && Immutable.is(this.props.column, nextProps.column) && this.props.dropEffect == nextProps.dropEffect && Immutable.is(this.props.path, nextProps.path) && this.props.canDrop && nextProps.canDrop && this.props.targetDisplay == nextProps.targetDisplay);
    return result;
  },

_handleAddModule: function _handleAddModule(event) {

if (-1 < document.body.className.indexOf("preview")) {
      return;
    }
    if (-1 < document.body.className.indexOf('mce-fullscreen')) {
      tinymce.activeEditor.execCommand('mceFullScreen');
    }
    store.dispatch(setSelection(this.props.path, 'single'));
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    store.dispatch(openDrawer('modulelist', Immutable.Map({ path: this.props.path, position: '', addType: 'push' })));
    event.stopPropagation();
  },

columnDesignHandler: function columnDesignHandler(children, path, column, moduleOptions, builderMode) {
    if (children.size === 0) {
      var style = { width: '100%', height: '100%', boxSizing: 'border-box', border: '1px dashed #a5a2a2' };
      return React.createElement(
        'div',
        { className: 'tatsu-empty-col', style: style, onClick: this._handleAddModule },
        React.createElement(
          'div',
          { id: 'tatsu-empty-col-add-tools-icon-wrapper' },
          React.createElement(
            'svg',
            { xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink', version: '1.1', x: '0px', y: '0px', viewBox: '0 0 100 100', style: { enableBackground: "new 0 0 100 100" }, xmlSpace: 'preserve' },
            React.createElement(
              'g',
              null,
              React.createElement('polygon', { points: '95.6,57.7 95.6,44.3 56.8,44.2 56.7,5.4 43.3,5.4 43.2,44.2 4.4,44.3 4.4,57.7 43.2,57.8 43.3,96.6 56.7,96.6    56.8,57.8  ' })
            )
          )
        )
      );
    } else {
      return (
        // <div className = "tatsu-header-column-wrap" >
        // {
        children.map(function (module) {
          var modulePath = path;
          modulePath = modulePath.push(children.indexOf(module));
          return React.createElement(Module, { builderMode: builderMode, pathFromSelectionState: this.props.pathFromSelectionState, dropEffect: this.props.dropEffect, key: module.get('id'), targetDisplay: this.props.targetDisplay, path: modulePath, parent: column, module: module, moduleOptions: moduleOptions });
        }.bind(this))
        // }
        // </div>

);
    }
  },

render: function render() {

var path = this.props.path,
        isOver = this.props.isOver,
        column = this.props.column,
        columnIndex = path.last(),
        colsCount = this.props.parent.get('inner').size,
        parentComponent = parentComponentFinder(path),
        columnClass = parentComponent.get('name') === 'tatsu_hamburger_menu' ? 'tatsu-slide-menu-col' : 'tatsu-header-col',
        idString = column.get('id'),
        children = column.get('inner'),
        moduleName = column.get('name'),
        connectDropTarget = this.props.connectDropTarget,
        moduleOptions = this.props.moduleOptions,
        attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']),
        atts = getAttsBasedOnTargetDisplay(column.get('atts'), this.props.targetDisplay, attsFromModuleOptions),
        moduleStyles = getModuleStyle(column, this.props.targetDisplay, moduleOptions),
        cssObject = getConcatenatedCSS(moduleStyles),
        columnId = atts.get('col_id'),
        columnStyle = jQuery.extend(true, {}, cssObject.style['.' + columnClass], { 'width': atts.get('column_width') + '%' }, cssObject.style['root']),
        deviceVisibility = atts.get('hide_in'),
        visibilityArray = [];

if (!isEmpty(deviceVisibility)) {
      visibilityArray = deviceVisibility.split(',');
      visibilityArray.forEach(function (device, index) {
        columnClass = columnClass + ' tatsu-hide-' + device + ' ';
      });
    }

return connectDropTarget(React.createElement(
      'div',
      { onContextMenu: this.handleRightClick, id: 'string' === typeof columnId && '' != columnId ? columnId : null, style: columnStyle, className: columnClass + " be-preview be-pb-observer-" + idString, onMouseEnter: this.mouseEnterHandler, onMouseLeave: this.mouseLeaveHandler, onClick: routeHandler.bind(null, path) },
      'desktop' === this.props.targetDisplay && 0 != columnIndex ? React.createElement(
        'div',
        { onMouseEnter: this.showWidthDragger.bind(null, 'left'), onMouseLeave: this.hideWidthDragger, onMouseDown: this.initColWidthDrag.bind(null, [columnIndex - 1, columnIndex]), className: "tatsu-column-width-dragger tatsu-column-width-dragger-left " + ('left' === this.state.widthDragger.get('position') ? 'visible' : '') },
        React.createElement('div', { className: 'tatsu-column-width-dragger-inner' })
      ) : null,
      this.props.widthDraggerPlaceholderPosition ? React.createElement(
        'div',
        { className: "tatsu-column-width-placeholder tatsu-column-width-placeholder-" + this.props.widthDraggerPlaceholderPosition },
        atts.get('column_width') + '%'
      ) : null,
      'desktop' !== this.props.targetDisplay || columnIndex !== colsCount - 1 ? React.createElement(
        'div',
        { onMouseEnter: this.showWidthDragger.bind(null, 'right'), onMouseLeave: this.hideWidthDragger, onMouseDown: this.initColWidthDrag.bind(null, [columnIndex, columnIndex + 1]), className: "tatsu-column-width-dragger tatsu-column-width-dragger-right " + ('right' === this.state.widthDragger.get('position') ? 'visible' : '') },
        React.createElement('div', { className: 'tatsu-column-width-dragger-inner' })
      ) : null,
      this.columnDesignHandler(children, path, column, moduleOptions, this.props.builderMode)
    ));
  }

});

module.exports = flow(DropTarget(dndScope.module, dropSpec, collect))(HeaderColumn);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 152 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, React, jQuery) {

var openContextMenu = __webpack_require__(2).openContextMenu,
    mapChecker = __webpack_require__(16).mapChecker,
    dndPageScroll = __webpack_require__(121),
    listChecker = __webpack_require__(16).listChecker,
    setDragPlaceholder = __webpack_require__(2).setDragPlaceholder,
    resetDragPlaceholder = __webpack_require__(2).resetDragPlaceholder,
    startDrag = __webpack_require__(2).startDrag,
    _endDrag = __webpack_require__(2).endDrag,
    routeHandler = __webpack_require__(99),
    triggerJs = __webpack_require__(126),
    triggerScript = __webpack_require__(242),
    cssAnimateHelper = __webpack_require__(120),
    CssAnimateNewHelper = __webpack_require__(124),
    getEmptyImage = __webpack_require__(304).getEmptyImage,
    findDOMNode = __webpack_require__(7).findDOMNode,
    reorderModules = __webpack_require__(2).reorderModules,
    builtInCollection = __webpack_require__(751),
    store = __webpack_require__(11),
    DragSource = __webpack_require__(37).DragSource,
    isEmpty = __webpack_require__(5),
    empty = __webpack_require__(182),
    DropTarget = __webpack_require__(37).DropTarget,
    flow = __webpack_require__(60),
    closeDrawer = __webpack_require__(2).closeDrawer,
    getAttsBasedOnDisplay = __webpack_require__(53),
    getModuleStyle = __webpack_require__(96),
    getConcatenatedCSS = __webpack_require__(67),
    dndScope = __webpack_require__(79).moduleListDnDConstant;
var dragSpec = {

isDragging: function isDragging(props, monitor) {

if (-1 < document.body.className.indexOf("preview") || 'tatsu_inline_text' == props.module.get('name')) {
            return false;
        } else {
            return true;
        }
    },
    beginDrag: function beginDrag(props, monitor, component) {

store.dispatch(closeDrawer());
        document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
        store.dispatch(startDrag('module'));
        dndPageScroll.showDragScroll(findDOMNode(component).className);
        return {
            draggedModulePath: 'copy' == props.dropEffect && Immutable.List.isList(props.pathFromSelectionState.get(0)) && props.pathFromSelectionState.contains(props.path) ? props.pathFromSelectionState : props.path,
            type: 'module',
            name: props.module.get('name')
        };
    },
    endDrag: function endDrag(props, monitor, component) {

var dropResult = monitor.getDropResult(),
            moduleOptions = props.moduleOptions,
            moduleName = monitor.getItem().name;
        dndPageScroll.hideDragScroll();
        if (!empty(dropResult)) {
            store.dispatch(reorderModules(dropResult.sourcePath, moduleName, dropResult.dropEffect));
        }
        store.dispatch(_endDrag());
    }
};
var dropSpec = {

drop: function drop(props, monitor) {

hover: function hover(props, monitor, component) {

function dragSourceCollect(connect, monitor) {

return {
        connectDragSource: connect.dragSource(),
        connectDragPreview: connect.dragPreview(),
        isDragging: monitor.isDragging()

};
}

function dropTargetCollect(connect, monitor) {

return {
        connectDropTarget: connect.dropTarget(),
        isOver: monitor.isOver()
    };
}

var Module = React.createClass({
    displayName: 'Module',

triggerJs: false,
    initialJsTriggered: false,
    animateObj: null,
    initialCssAnimationTriggered: false,
    triggerAnimation: false,
    rowThreshold: null,
    propTypes: {
        path: listChecker,
        pathFromSelectionState: listChecker,
        module: mapChecker,
        connectDragSource: React.PropTypes.func.isRequired,
        isDragging: React.PropTypes.bool.isRequired,
        dropEffect: React.PropTypes.string,
        connectDropTarget: React.PropTypes.func.isRequired,
        isOver: React.PropTypes.bool.isRequired,
        connectDragPreview: React.PropTypes.func.isRequired,
        moduleOptions: mapChecker,
        parent: mapChecker,
        targetDisplay: React.PropTypes.string
    },

getInitialState: function getInitialState() {

return {
            loader: false,
            placeHolder: false
        };
    },

componentWillMount: function componentWillMount() {

var isFetching = this.props.module.get('isFetching'),
            childModuleName,
            childModuleAttArray,
            moduleAtts = this.props.module.get('atts'),
            childrenAnimatable = false;
        if ('multi' == this.props.module.get('type')) {
            childModuleName = this.props.moduleOptions.getIn([this.props.module.get('name'), 'child_module']);
            childModuleAttArray = this.props.moduleOptions.getIn([childModuleName, 'atts']);

if ('undefined' != typeof childModuleAttArray && 'tatsu_inner_column' != childModuleName) {
                childrenAnimatable = childModuleAttArray.map(function (att) {

return att.get('att_name');
                }).contains('animate');
            }
        }
        if (isFetching) {
            this.setState({
                placeHolder: true
            });
        }
        if (this.props.moduleOptions.getIn([this.props.module.get('name'), 'is_js_dependant']) && (this.props.moduleOptions.getIn([this.props.module.get('name'), 'is_built_in']) || !this.props.module.get('isFetching'))) {
            this.triggerJs = true;
        }
        if ('tatsu_svg_icon' !== this.props.module.get('name') && (moduleAtts.has('animate') || childrenAnimatable)) {
            this.animateObj = new CssAnimateNewHelper(this.props.module, childrenAnimatable);
            if (this.props.moduleOptions.getIn([this.props.module.get('name'), 'is_built_in']) || !this.props.module.get('isFetching')) {
                this.triggerAnimation = true;
            }
        }
    },

routeHandleWrapper: function routeHandleWrapper(event) {

routeHandler(this.props.path, event);

if (this.props.module.get('name') === 'tatsu_hamburger_menu') {
            var currentDocument = document.getElementById('tatsu-preview').contentDocument;
            jQuery(currentDocument).find('#hamburger-' + this.props.module.get('id') + ' .tatsu-slide-menu').addClass('open');
            jQuery(currentDocument).find('#tatsu-fixed-overlay').addClass('open');
        }
    },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

componentDidUpdate: function componentDidUpdate() {

handleRightClick: function handleRightClick(event) {

if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        event.preventDefault();
        event.stopPropagation();
        var currentTop = event.clientY,
            currentLeft = event.clientX + (-1 < document.body.className.indexOf('mce-fullscreen') ? 0.3 * window.innerWidth : 300),
            path = this.props.path,
            id = this.props.module.get('id'),
            name = this.props.module.get('name'),
            clientRect = findDOMNode(this).getBoundingClientRect(),
            title = this.props.module.get('title'),
            builderType = this.props.module.get('type');

store.dispatch(openContextMenu(currentTop, currentLeft, path, name, title, id, clientRect, builderType));
    },

componentDidMount: function componentDidMount() {

this.props.connectDragPreview(getEmptyImage(), { captureDraggingState: true });
        var moduleOptions = this.props.moduleOptions,
            moduleName = this.props.module.get('name'),
            moduleId = this.props.module.get('id'),
            moduleType = moduleOptions.getIn([moduleName, 'type']),
            path = this.props.path;
        if (this.triggerJs) {
            this.triggerJs = false;
            triggerJs(moduleName, this.initialJsTriggered, moduleId);
            if (!this.initialJsTriggered) {
                this.initialJsTriggered = true;
            }
        }
        if (this.triggerAnimation && !this.initialCssAnimationTriggered) {
            this.triggerAnimation = false;
            this.initialCssAnimationTriggered = true;
            this.animateObj.init(this.props.moduleOptions);
        }
    },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true,
            moduleOptions = this.props.moduleOptions,
            moduleName = this.props.module.get('name'),
            hasResponsiveAttsorModuleIsInnerRow = 'tatsu_inner_row' == moduleName || this.props.module.get('atts').valueSeq().some(function (attValue) {

return Immutable.Map.isMap(attValue);
        });
        result = !(Immutable.is(this.props.module, nextProps.module) && (!hasResponsiveAttsorModuleIsInnerRow || this.props.targetDisplay == nextProps.targetDisplay) && ('tatsu_inner_row' != moduleName || Immutable.is(this.props.pathFromSelectionState, nextProps.pathFromSelectionState) && Immutable.is(this.props.path, nextProps.path) && this.props.dropEffect == nextProps.dropEffect) && this.props.isDragging === nextProps.isDragging && this.state.placeHolder == nextState.placeHolder && this.state.loader == nextState.loader);
        return result;
    },

builtInModuleHelper: function builtInModuleHelper(module, isDragging, moduleOptions) {

var moduleName = module.get('name'),
            attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']),
            atts = getAttsBasedOnDisplay(module.get('atts'), this.props.targetDisplay, attsFromModuleOptions),
            moduleStyles = getModuleStyle(module, this.props.targetDisplay, moduleOptions),
            cssObject = getConcatenatedCSS(moduleStyles),
            builderMode = this.props.builderMode ? this.props.builderMode : '',
            DynamicBuiltIn;

builtInCollection.tatsu_inner_row = __webpack_require__(156);
        if (!isEmpty(moduleName)) {
            DynamicBuiltIn = builtInCollection[moduleName];
            if (isEmpty(DynamicBuiltIn)) {
                DynamicBuiltIn = tatsuConfig[moduleName];
                if (isEmpty(DynamicBuiltIn)) {
                    return null;
                }
            }
        } else {
            return null;
        }

if ('tatsu_inner_row' == moduleName) {
            return React.createElement(DynamicBuiltIn, { builderMode: builderMode, pathFromSelectionState: this.props.pathFromSelectionState, row: module, moduleOptions: moduleOptions, path: this.props.path, parent: this.props.parent, dropEffect: this.props.dropEffect, targetDisplay: this.props.targetDisplay });
        } else if ('tatsu_hamburger_menu' == moduleName) {
            return React.createElement(DynamicBuiltIn, { builderMode: builderMode, pathFromSelectionState: this.props.pathFromSelectionState, module: module, cssObject: cssObject, moduleOptions: moduleOptions, path: this.props.path, parent: this.props.parent, dropEffect: this.props.dropEffect, targetDisplay: this.props.targetDisplay });
        } else {
            return React.createElement(DynamicBuiltIn, { builderMode: builderMode, module: module, moduleOptions: moduleOptions, path: this.props.path, atts: atts, cssObject: cssObject, targetDisplay: this.props.targetDisplay });
        }
    },

mouseEnterHandler: function mouseEnterHandler(event) {

if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        if (curPath.size > 4) {
            jQuery(currentDocument).find('#tatsu-observer', '#tatsu-selection-tooltip').addClass('higher-z-index');
        }

document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
        if (!(isMultiSelected && selectionPath.contains(curPath) || Immutable.is(curPath, selectionPath))) {
            var title = this.props.moduleOptions.getIn([this.props.module.get('name'), 'title']) || 'Module',
                messageData = 'hover_set,' + this.props.module.get('id') + ',' + title;
            document.getElementById('tatsu-preview').contentWindow.postMessage(messageData, '*');
        }
    },

mouseLeaveHandler: function mouseLeaveHandler(event) {

//For Header Builder
        var currentDocument = document.getElementById('tatsu-preview').contentDocument;
        jQuery(currentDocument).find('#tatsu-observer').removeClass('higher-z-index');

if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        var parent = this.props.parent,
            isMultiSelected = Immutable.List.isList(this.props.pathFromSelectionState.get(0)),
            selectionPath = this.props.pathFromSelectionState,
            parentPath = this.props.path.pop();
        document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
        if (parent && !(isMultiSelected && selectionPath.contains(parentPath) || Immutable.is(parentPath, selectionPath))) {
            var parentTitle = this.props.moduleOptions.getIn([parent.get('name'), 'title']) || 'Tatsu Column';
            document.getElementById('tatsu-preview').contentWindow.postMessage('hover_set,' + parent.get('id') + ',' + parentTitle, '*');
        }
    },

moduleRenderer: function moduleRenderer(module, isDragging, path, moduleOptions) {

var path = this.props.path,
            isDragging = this.props.isDragging,
            connectDragSource = this.props.connectDragSource,
            connectDropTarget = this.props.connectDropTarget,
            module = this.props.module,
            moduleOptions = this.props.moduleOptions;
        var currentModule = this.moduleRenderer(module, isDragging, path, moduleOptions);
        return 'tatsu_inline_text' == module.get('name') || 'tatsu_image_carousel' == module.get('name') || 'tatsu_inner_row' == module.get('name') ? connectDropTarget(currentModule) : connectDragSource(connectDropTarget(currentModule), { dropEffect: this.props.dropEffect });
    }

});
module.exports = flow(DragSource(dndScope.module, dragSpec, dragSourceCollect), DropTarget(dndScope.module, dropSpec, dropTargetCollect))(Module);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 153 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, React, jQuery) {

var keyPath = __webpack_require__(39),
    flow = __webpack_require__(60),
    empty = __webpack_require__(182),
    isEqual = __webpack_require__(86),
    routeResolve = __webpack_require__(33),
    hideSelection = __webpack_require__(2).hideSelection,
    addSelectedStyle = __webpack_require__(80).addSelectedStyle,
    removeSelectedStyle = __webpack_require__(80).removeSelectedStyle,
    findDOMNode = __webpack_require__(7).findDOMNode,
    getEmptyImage = __webpack_require__(304).getEmptyImage,
    reorderModules = __webpack_require__(2).reorderModules,
    setSelection = __webpack_require__(2).setSelection,
    startDrag = __webpack_require__(2).startDrag,
    _endDrag = __webpack_require__(2).endDrag,
    dndPageScroll = __webpack_require__(121),
    DragSource = __webpack_require__(37).DragSource,
    store = __webpack_require__(11);
var dragSpec = {

beginDrag: function beginDrag(props, monitor, component) {

var parentRoute = routeResolve(window.location.pathname),
		    currentSelectedModule;
		document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
		store.dispatch(hideSelection());
		store.dispatch(startDrag('module'));
		dndPageScroll.showDragScroll(findDOMNode(component).className);
		return {
			draggedModulePath: Immutable.List.isList(props.pathFromSelectionState.get(0)) ? props.pathFromSelectionState.contains(props.path) && 'copy' == props.dropEffect ? props.pathFromSelectionState : props.path : props.path,
			type: 'module',
			name: props.name
		};
	},

endDrag: function endDrag(props, monitor) {

var dropResult = monitor.getDropResult(),
		    moduleName = monitor.getItem().name;
		dndPageScroll.hideDragScroll();
		if (!empty(dropResult)) {
			store.dispatch(reorderModules(dropResult.sourcePath, moduleName, dropResult.dropEffect));
		}
		store.dispatch(_endDrag());
	}

};
function dragSourceCollect(connect, monitor) {

return {
		connectDragSource: connect.dragSource(),
		connectDragPreview: connect.dragPreview()
	};
}
var Observer = React.createClass({
	displayName: 'Observer',

getInitialState: function getInitialState(e) {
		return {
			isTitle: false,
			titleWidth: null
		};
	},
	onTitleClick: function onTitleClick(e) {
		var currentNode,
		    currentState = this.state.isTitle;
		if (!currentState) {
			currentNode = findDOMNode(this);
			if (null != currentNode) {
				var titleEle = currentNode.querySelector('.tatsu-selection-tooltip-title'),
				    titleWidth = titleEle.offsetWidth;
				this.setState({
					isTitle: true,
					width: titleWidth + 'px'
				});
			}
		} else {
			this.setState({
				isTitle: false,
				width: null
			});
		}
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
		return !isEqual(this.props, nextProps) || !isEqual(this.state, nextState);
	},

componentDidMount: function componentDidMount() {

componentWillUnmount: function componentWillUnmount() {

removeSelectedStyle(this.props.id);
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

if (!this.props.hide && nextProps.hide) {
			removeSelectedStyle(this.props.id);
		} else if (this.props.hide && !nextProps.hide) {
			addSelectedStyle(this.props.id);
		}
	},

getObserverTools: function getObserverTools() {

if (this.props.availableTools) {
			return this.props.availableTools.map(function (tool, index) {
				return React.createElement(
					'div',
					{ key: index, className: 'tatsu-observer-tool', onClick: this.props.triggerTool.bind(null, tool, this.props.path, this.props.name) },
					'layout' == tool ? React.createElement(
						'svg',
						{ xmlns: 'http://www.w3.org/2000/svg', fill: '#fff', viewBox: '0 0 19 12' },
						React.createElement('path', { fillRule: 'evenodd', clipRule: 'evenodd', d: 'M18.775 5.48067L18.2004 4.87757C16.1522 2.7048 13.6008 0 9.50049 0C5.42463 0 2.70022 2.87334 0.709684 4.97199L0.224998 5.48067C-0.0749993 5.79237 -0.0749993 6.29596 0.224998 6.60665L0.616851 7.01582C2.62205 9.11955 5.36795 12 9.50049 12C13.6535 12 16.2236 9.29317 18.2835 7.11938L18.775 6.60564C19.075 6.29596 19.075 5.79237 18.775 5.48067ZM9.50049 10.408C6.08716 10.408 3.82888 8.11947 1.84616 6.04214C3.83474 3.94754 6.09303 1.59303 9.50049 1.59303C12.9558 1.59303 15.1604 3.92927 17.1069 5.99137L17.1548 6.04315C15.2053 8.09713 12.99 10.408 9.50049 10.408Z' }),
						React.createElement('path', { fillRule: 'evenodd', clipRule: 'evenodd', d: 'M9.5 7C10.3284 7 11 6.32843 11 5.5C11 4.67157 10.3284 4 9.5 4C8.67157 4 8 4.67157 8 5.5C8 6.32843 8.67157 7 9.5 7Z' })
					) : 'duplicate' == tool ? React.createElement(
						'svg',
						{ fill: '#fff', viewBox: '0 0 100 100' },
						React.createElement('path', { d: 'M86,14H27.5v58.5H86V14z M80.1,66.6H33.4V19.9h46.7V66.6z M69.5,86H14V30.5h5.9v49.7h49.7V86z M53.8,46.2  H42.4v-5.9h11.4V28.9h5.9v11.4h11.4v5.9H59.7v11.4h-5.9V46.2z' })
					) : React.createElement(
						'svg',
						{ fill: '#fff', viewBox: '0 0 100 100' },
						React.createElement('path', { d: 'M67.6683908,76.9065599 C67.632523,77.7673863 66.8667215,78.5 65.9999745,78.5 L34.0000255,78.5 C33.1336268,78.5 32.3673911,77.7653262 32.3316092,76.9065599 L30.4978327,32.8959236 C30.4403529,31.5164087 29.2754385,30.4446875 27.8959236,30.5021673 C26.5164087,30.5596471 25.4446875,31.7245615 25.5021673,33.1040764 L27.3359438,77.1147127 C27.4833334,80.6520627 30.453619,83.5 34.0000255,83.5 L65.9999745,83.5 C69.5442642,83.5 72.5164778,80.6565944 72.6640562,77.1147127 L74.4978327,33.1040764 C74.5553125,31.7245615 73.4835913,30.5596471 72.1040764,30.5021673 C70.7245615,30.4446875 69.5596471,31.5164087 69.5021673,32.8959236 L67.6683908,76.9065599 Z M48,71 C48,72.1045695 48.8954305,73 50,73 C51.1045695,73 52,72.1045695 52,71 L52,37 C52,35.8954305 51.1045695,35 50,35 C48.8954305,35 48,35.8954305 48,37 L48,71 Z M38.0008645,71.0587981 C38.0333378,72.1628902 38.954706,73.0316088 40.0587981,72.9991355 C41.1628902,72.9666622 42.0316088,72.045294 41.9991355,70.9412019 L40.9991355,36.9412019 C40.9666622,35.8371098 40.045294,34.9683912 38.9412019,35.0008645 C37.8371098,35.0333378 36.9683912,35.954706 37.0008645,37.0587981 L38.0008645,71.0587981 Z M58.0008645,70.9412019 C57.9683912,72.045294 58.8371098,72.9666622 59.9412019,72.9991355 C61.045294,73.0316088 61.9666622,72.1628902 61.9991355,71.0587981 L62.9991355,37.0587981 C63.0316088,35.954706 62.1628902,35.0333378 61.0587981,35.0008645 C59.954706,34.9683912 59.0333378,35.8371098 59.0008645,36.9412019 L58.0008645,70.9412019 Z M62.314325,22 L61.3628045,18.6696783 C60.5262772,15.741833 57.5532275,13.5 54.5085033,13.5 L45.4914967,13.5 C42.4471337,13.5 39.4734928,15.742638 38.6371955,18.6696783 L37.685675,22 L25,22 C23.6192881,22 22.5,23.1192881 22.5,24.5 C22.5,25.8807119 23.6192881,27 25,27 L75,27 C76.3807119,27 77.5,25.8807119 77.5,24.5 C77.5,23.1192881 76.3807119,22 75,22 L62.314325,22 L62.314325,22 Z M54.5085033,18.5 L45.4914967,18.5 C44.6793677,18.5 43.6677785,19.2629127 43.4448153,20.0432839 L42.8857535,22 L57.1142465,22 L56.5551847,20.0432839 C56.3320347,19.2622589 55.3211505,18.5 54.5085033,18.5 Z' })
					)
				);
			}.bind(this));
		}
		return null;
	},

render: function render() {

var dropUpIcon = React.createElement(
			'svg',
			{ width: '8px', height: '5px', viewBox: '0 0 8 5', version: '1.1', xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink' },
			React.createElement(
				'g',
				{ stroke: 'none', strokeWidth: '1', fillRule: 'evenodd', transform: 'translate(-261.000000, -437.000000)' },
				React.createElement(
					'g',
					{ transform: 'translate(0.000000, 142.000000)', fillRule: 'nonzero' },
					React.createElement(
						'g',
						{ transform: 'translate(21.000000, 282.000000)' },
						React.createElement(
							'g',
							{ transform: 'translate(96.000000, 0.000000)' },
							React.createElement(
								'g',
								{ transform: 'translate(144.000000, 13.000000)' },
								React.createElement('path', { d: 'M0.221982479,0.221788177 C0.0798580504,0.364395175 0,0.557907646 0,0.759697352 C0,0.961487057 0.0798580504,1.15499953 0.221982479,1.29760653 L3.49026398,4.58787781 C3.62511277,4.72367887 3.80821197,4.8 3.99915848,4.8 C4.19010498,4.8 4.37320418,4.72367887 4.50805298,4.58787781 L7.77849081,1.2968845 C8.0738364,1.00020423 8.0738364,0.519190473 7.77849081,0.222510203 C7.48314522,-0.0741700676 7.00429541,-0.0741700676 6.70894982,0.222510203 L3.99915848,2.94887939 L1.29080469,0.222510203 C1.14911382,0.0800522434 0.956863996,9.52869805e-06 0.756393583,9.52869805e-06 C0.555923171,9.52869805e-06 0.363673346,0.0800522434 0.221982479,0.222510203 L0.221982479,0.221788177 Z', id: 'Shape' })
							)
						)
					)
				)
			)
		);

var breadcrumbPath = this.props.path,
		    currentPath = Immutable.List(),
		    breadcrumbTitle = [],
		    moduleOptions = this.props.moduleOptions;

breadcrumbPath.forEach(function (path, index) {
			currentPath = currentPath.push(path);
			var targetElement = getTargetElementFromPath(currentPath),
			    parentElement = getTargetElementFromPath(currentPath.pop()),
			    title = '';
			if (targetElement) {
				title = targetElement.get('title') || moduleOptions.getIn([targetElement.get('name'), 'title']) || 'Module';
				if (parentElement) {
					if ('sub_module' == targetElement.get('type') || 'tatsu_button_group' == parentElement.get('name') || 'tatsu_icon_group' == parentElement.get('name')) {
						return;
					}
				}
				breadcrumbTitle.push({ name: title, path: currentPath });
			}
		});
		breadcrumbTitle.pop();
		var connectDragSource = this.props.connectDragSource,
		    path = this.props.path,
		    id = this.props.id,
		    top = this.props.top,
		    left = this.props.left,
		    hidden = this.props.hide,
		    title = this.props.title,
		    name = this.props.name;

var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';

// return ((path.size > 3 && name !== 'tatsu_inner_column' ) ? connectDragSource(<div>
		return this.props.builderType !== 'core' ? connectDragSource(React.createElement(
			'div',
			null,
			React.createElement(
				'div',
				{ id: 'tatsu-selection-tooltip', className: 'tatsu-draggable-selection-header out', style: { top: top - 10, left: left, opacity: hidden ? '0' : '1' } },
				this.state.isTitle && React.createElement(
					'div',
					{ style: { left: 'tatsu_inner_column' != name ? 39 : null, width: this.state.width }, className: 'tatsu-selection-breadcrumb' },
					breadcrumbTitle.map(function (title) {
						return React.createElement(
							'div',
							{ onClick: function onClick() {
									store.dispatch(setSelection(title.path, 'single'));
								}, className: 'tatsu-selection-breadcrumb-item' },
							title.name
						);
					})
				),
				React.createElement(
					'div',
					{ className: 'tatsu-observer-drag-indicator' },
					React.createElement(
						'svg',
						{ fill: '#fff', style: { padding: '0px' }, viewBox: '0 0 512 512' },
						React.createElement('path', { d: 'M507,249l-81.3-66.2c-6.4-6.4-17.3-1.9-17.3,7.2v40.7h-127v-127h40.7c9,0,13.5-10.9,7.2-17.3L263.3,5c-4-4-10.4-4-14.3,0  l-66.2,81.3c-6.4,6.4-1.9,17.3,7.2,17.3h40.7v127h-127v-40.7c0-9-10.9-13.5-17.3-7.2L5,248.7c-4,4-4,10.4,0,14.3l81.3,66.2  c6.4,6.4,17.3,1.9,17.3-7.2v-40.7h127v127h-40.7c-9,0-13.5,10.9-7.2,17.3l65.9,81.3c4,4,10.4,4,14.3,0l66.2-81.3  c6.4-6.4,1.9-17.3-7.2-17.3h-40.7v-127h127V322c0,9,10.9,13.5,17.3,7.2l81.3-65.9C511,259.3,511,252.9,507,249z' })
					)
				),
				React.createElement(
					'div',
					{ className: 'tatsu-selection-tooltip-title', onClick: this.onTitleClick },
					React.createElement(
						'div',
						{ className: 'tatsu-observer-title-inner' },
						title
					),
					React.createElement(
						'div',
						{ className: this.state.isTitle ? 'tatsu-observer-dropup-icon  open' : 'tatsu-observer-dropup-icon ' },
						dropUpIcon
					)
				),
				this.getObserverTools()
			)
		)) : React.createElement(
			'div',
			{ id: 'tatsu-selection-tooltip', className: 'tatsu_section' != name && 'Header Row' != title ? 'tatsu-normal-pad out' : 'tatsu-normal-pad in', style: { top: 'tatsu_section' === name || title === 'Header Row' ? top + 9 : top - 6, left: 'tatsu_section' === name || title === 'Header Row' ? left + 3 : left, visibility: hidden ? 'hidden' : 'visible' } },
			this.state.isTitle && React.createElement(
				'div',
				{ className: 'tatsu-selection-breadcrumb', style: { width: this.state.width } },
				breadcrumbTitle.map(function (title) {
					return React.createElement(
						'div',
						{ onClick: function onClick() {
								store.dispatch(setSelection(title.path, 'single'));
							}, className: 'tatsu-selection-breadcrumb-item' },
						title.name
					);
				})
			),
			React.createElement(
				'div',
				{ className: 'tatsu-selection-tooltip-title', onClick: this.onTitleClick },
				React.createElement(
					'div',
					{ className: 'tatsu-observer-title-inner' },
					title
				),
				'tatsu_section' != name && React.createElement(
					'div',
					{ className: this.state.isTitle ? 'tatsu-observer-dropup-icon  open' : 'tatsu-observer-dropup-icon ' },
					dropUpIcon
				)
			),
			(title === 'Column' || title === 'Inner Column') && React.createElement(
				'div',
				{ className: 'tatsu-observer-tool', onClick: function onClick() {
						store.dispatch(setSelection(breadcrumbPath.pop(), 'single'));
					} },
				' ',
				React.createElement(
					'svg',
					{ width: '18px', height: '16px', viewBox: '0 0 18 16' },
					React.createElement('rect', { stroke: '#fff', fill: primaryColor, x: '11', y: '1', width: '6', height: '14' }),
					React.createElement('rect', { stroke: '#fff', fill: primaryColor, x: '1', y: '1', width: '6', height: '14' })
				),
				' '
			),
			this.getObserverTools()
		);
	}

});
module.exports = flow(DragSource('moduleList', dragSpec, dragSourceCollect))(Observer);

function getTargetElementFromPath(path) {

if (0 < path.size) {
		var currentPathArray = keyPath(path, '', '');
		return store.getState().tatsu_page_content.get('present').getIn(currentPathArray);
	}
	return null;
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 154 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _icon = __webpack_require__(52);

var _icon2 = _interopRequireDefault(_icon);

__webpack_require__(347);

__webpack_require__(407);

var _index = __webpack_require__(155);

var _index2 = _interopRequireDefault(_index);

var _EditorHelpers = __webpack_require__(26);

var _index3 = __webpack_require__(648);

var _index4 = _interopRequireDefault(_index3);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var BePopoverMenu = function (_React$Component) {
    _inherits(BePopoverMenu, _React$Component);

function BePopoverMenu(props) {
        _classCallCheck(this, BePopoverMenu);

var _this = _possibleConstructorReturn(this, (BePopoverMenu.__proto__ || Object.getPrototypeOf(BePopoverMenu)).call(this, props));

_this.icon = null;
        _this.state = {
            open: false
        };
        _this.toggleClick = _this.toggleClick.bind(_this);
        return _this;
    }

_createClass(BePopoverMenu, [{
        key: 'toggleClick',
        value: function toggleClick(e) {
            this.setState({
                open: !this.state.open
            });
            e.stopPropagation();
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

return BePopoverMenu;
}(React.Component);

exports.default = BePopoverMenu;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 155 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

__webpack_require__(408);

var _EditorConstants = __webpack_require__(95);

var _reactTransitionGroup = __webpack_require__(506);

var _EditorHelpers = __webpack_require__(26);

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

//const  = constants;

var Popover = function (_React$Component) {
    _inherits(Popover, _React$Component);

function Popover(props) {
        _classCallCheck(this, Popover);

var _this = _possibleConstructorReturn(this, (Popover.__proto__ || Object.getPrototypeOf(Popover)).call(this, props));

_this.state = {
            bottom: null,
            right: null
        };
        _this.handleEdgeClick = _this.handleEdgeClick.bind(_this);
        _this.hitsBottom = false;
        return _this;
    }

_createClass(Popover, [{
        key: 'componentDidUpdate',
        value: function componentDidUpdate(prevProps, prevState) {
            if (!prevProps.open && this.props.open) {
                this.setState({
                    bottom: this.dummyEle.getBoundingClientRect().bottom,
                    right: this.dummyEle.getBoundingClientRect().right
                });
            }
            if (prevProps.open && !this.props.open) {
                this.setState({
                    bottom: null,
                    right: null
                });
            }
        }
    }, {
        key: 'validateBoundaries',
        value: function validateBoundaries(boundaries) {
            if ((0, _EditorHelpers.isValidDataStructure)(boundaries) && (0, _EditorHelpers.hasKeys)(boundaries, ['top', 'left', 'bottom', 'right']) && (0, _EditorHelpers.validateValues)(boundaries, true, false, false)) {
                return true;
            }
            return false;
        }
    }, {
        key: 'validateAnchorCoords',
        value: function validateAnchorCoords(anchorCoords) {
            if ((0, _EditorHelpers.isValidDataStructure)(anchorCoords) && (0, _EditorHelpers.hasKeys)(anchorCoords, ['top', 'left']) && (0, _EditorHelpers.validateValues)(anchorCoords)) {
                return true;
            }
            return false;
        }
    }, {
        key: 'handleEdgeClick',
        value: function handleEdgeClick(anchorCoords, wrapWithinViewport) {
            var _state = this.state,
                bottom = _state.bottom,
                right = _state.right;

if (null != bottom && null != right) {
                var viewportBottom = window.innerHeight,
                    viewportRight = window.innerWidth;

if (_typeof(this.props.positionAdjustment) === 'object') {
                    anchorCoords.left = parseInt(anchorCoords.left) + this.props.positionAdjustment.left;
                }

if (wrapWithinViewport) {
                    if (right > viewportRight) {
                        anchorCoords.right = viewportRight - parseInt(anchorCoords.left);
                        anchorCoords.left = "auto";
                    }
                    if (bottom > viewportBottom) {
                        anchorCoords.bottom = viewportBottom - parseInt(anchorCoords.top);
                        anchorCoords.top = "auto";
                        this.hitsBottom = true;
                    } else {
                        if (_typeof(this.props.positionAdjustment) === 'object') {
                            anchorCoords.top = parseInt(anchorCoords.top) + this.props.positionAdjustment.top;
                        }
                        this.hitsBottom = false;
                    }
                }
            }
            return anchorCoords;
        }
    }, {
        key: 'parseAnchorCoords',
        value: function parseAnchorCoords(anchorEl, anchorCoords, wrapWithinViewport) {

if (null != anchorEl) {
                var top = anchorEl.getBoundingClientRect().top,
                    left = anchorEl.getBoundingClientRect().left;

anchorCoords = {
                    top: top + 'px',
                    left: left + 'px'
                };

return this.handleEdgeClick(anchorCoords, wrapWithinViewport);
            }
            if (this.validateAnchorCoords(anchorCoords)) {
                return this.handleEdgeClick(anchorCoords, wrapWithinViewport);
            }
            return null;
        }
    }, {
        key: 'getTransformOrigin',
        value: function getTransformOrigin(wrapWithinViewport, bottom, right) {
            var transformOrigin = {
                horizontal: 'left',
                vertical: 'top'
            };
            if (wrapWithinViewport) {
                var viewportRight = window.innerWidth,
                    viewportBottom = window.innerHeight;
                if (bottom > viewportBottom) {
                    transformOrigin.vertical = 'bottom';
                }
                if (right > viewportRight) {
                    transformOrigin.horizontal = 'right';
                }
            }
            return transformOrigin;
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

var open = this.props.open,
                _state2 = this.state,
                bottom = _state2.bottom,
                right = _state2.right,
                duration = this.props.duration,
                wrapWithinViewport = this.props.wrapWithinViewport,
                transformOrigin = this.getTransformOrigin(wrapWithinViewport, bottom, right),
                cubicBezier = 'string' == typeof this.props.cubicBezier ? this.props.cubicBezier : 'ease-in',
                anchorEl = this.props.anchorEl instanceof Node ? this.props.anchorEl : null,
                widthStyleObj = {
                width: 'string' == typeof this.props.width ? this.props.width : '300px'
            },
                anchorCoords = this.parseAnchorCoords(anchorEl, this.props.anchorCoords, wrapWithinViewport);

return React.createElement(
                'div',
                { className: (0, _EditorHelpers.getClassNames)('be-ui-component', this.props.className, 'be-popover-wrap') },
                open && bottom && [React.createElement('div', { onClick: this.props.handleClickAway, className: 'be-popover-overlay' }), React.createElement(
                    _reactTransitionGroup.Transition,
                    {
                        mountOnEnter: true,
                        unmountOnExit: true,
                        'in': open,
                        appear: true,
                        timeout: 300,
                        onEnter: function onEnter(node) {
                            return node.scrollTop;
                        }
                    },
                    function (state) {
                        return React.createElement(
                            'div',
                            { className: "be-popover " + (_this2.hitsBottom ? " be-popover-bottom" : "be-popover-top"), style: jQuery.extend({}, (0, _EditorConstants.getPopoverTransitionObj)(duration, cubicBezier, transformOrigin).defaultStyle, (0, _EditorConstants.getPopoverTransitionObj)(duration, cubicBezier, transformOrigin)[state], anchorCoords, widthStyleObj) },
                            _this2.props.children
                        );
                    }
                )],
                open && !bottom && React.createElement(
                    'div',
                    { ref: function ref(dummyEle) {
                            _this2.dummyEle = dummyEle;
                        }, style: jQuery.extend({ position: 'fixed', visibility: 'hidden' }, anchorCoords, widthStyleObj) },
                    this.props.children
                )
            );
        }
    }]);

return Popover;
}(React.Component);

exports.default = Popover;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 156 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

var Column = __webpack_require__(217),
    closeDrawer = __webpack_require__(2).closeDrawer,
    findDOMNode = __webpack_require__(7).findDOMNode,
    routeHandler = __webpack_require__(99),
    setSelection = __webpack_require__(2).setSelection,
    resetSelection = __webpack_require__(2).resetSelection,
    store = __webpack_require__(11),
    isEqual = __webpack_require__(86),
    checkIfSelected = __webpack_require__(80).checkIfSelected,
    isEmpty = __webpack_require__(5),
    openContextMenu = __webpack_require__(2).openContextMenu,
    getAttsBasedOnTargetDisplay = __webpack_require__(53),
    getModuleStyle = __webpack_require__(96),
    getConcatenatedCSS = __webpack_require__(67),
    triggerJs = __webpack_require__(126),
    cssAnimateHelper = __webpack_require__(120),
    CssNewAnimate = __webpack_require__(124),
    routeResolve = __webpack_require__(33),
    encodePath = __webpack_require__(43).encodePath,
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    Row = React.createClass({
    displayName: 'Row',

propTypes: {
        row: mapChecker,
        path: listChecker,
        parent: mapChecker,
        moduleOptions: mapChecker,
        pathFromSelectionState: listChecker,
        dropEffect: React.PropTypes.string,
        targetDisplay: React.PropTypes.string
    },

getInitialState: function getInitialState() {
        return {
            curDraggingCols: []
        };
    },

triggerJs: false,

mouseEnterHandler: function mouseEnterHandler(event) {

var isMultiSelected = Immutable.List.isList(this.props.pathFromSelectionState.get(0)),
            selectionPath = this.props.pathFromSelectionState,
            curPath = this.props.path;
        if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
        if (!(isMultiSelected && selectionPath.contains(curPath) || Immutable.is(curPath, selectionPath))) {
            var rowTitle = this.props.moduleOptions.getIn(['tatsu_row', 'title']) || 'Tatsu Row',
                messageData = 'hover_set,' + this.props.row.get('id') + ',' + rowTitle;
            document.getElementById('tatsu-preview').contentWindow.postMessage(messageData, '*');
        }
    },

componentWillMount: function componentWillMount() {
        this.animateObj = new CssNewAnimate(this.props.row, false);
    },

componentDidMount: function componentDidMount() {
        this.animateObj.init();
    },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

if (this.props.row.getIn(['atts', 'full_width']) != nextProps.row.getIn(['atts', 'full_width'])) {
            this.triggerJs = true;
        }
    },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
        result = !(Immutable.is(this.props.pathFromSelectionState, nextProps.pathFromSelectionState) && Immutable.is(this.props.path, nextProps.path) && this.props.dropEffect == nextProps.dropEffect && Immutable.is(this.props.row, nextProps.row) && this.props.targetDisplay == nextProps.targetDisplay && isEqual(this.state, nextState));
        return result;
    },

handleRightClick: function handleRightClick(event) {

if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        event.preventDefault();
        event.stopPropagation();
        var currentTop = event.clientY,
            currentLeft = event.clientX + (-1 < document.body.className.indexOf('mce-fullscreen') ? 0.3 * window.innerWidth : 300),
            path = this.props.path,
            name = this.props.row.get('name'),
            id = this.props.row.get('id'),
            clientRect = findDOMNode(this).getBoundingClientRect(),
            title = this.props.row.get('title');
        store.dispatch(openContextMenu(currentTop, currentLeft, path, name, title, id, clientRect));
    },

componentDidUpdate: function componentDidUpdate(nextProps, nextState) {

cssAnimateHelper(this);
        this.animateObj.triggerAnimation(this.props.row);
        if (this.triggerJs) {
            this.triggerJs = false;
            var jsTriggerData, jsTriggerJSONData;
            jsTriggerData = {
                type: 'jstrigger',
                moduleName: 'trigger_ready'
            };
            jsTriggerJSONData = JSON.stringify(jsTriggerData);
            document.getElementById('tatsu-preview').contentWindow.postMessage(jsTriggerJSONData, '*');
        }
        if (nextProps.row.getIn(['atts', 'equal_height_columns']) !== this.props.row.getIn(['atts', 'equal_height_columns'])) {
            triggerJs('tatsu_row', true, 'none');
        }
    },

mouseLeaveHandler: function mouseLeaveHandler() {

if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        var parent = this.props.parent,
            isMultiSelected = Immutable.List.isList(this.props.pathFromSelectionState.get(0)),
            selectionPath = this.props.pathFromSelectionState,
            parentPath = this.props.path.pop();
        document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
        if (parent && !(isMultiSelected && selectionPath.contains(parentPath) || Immutable.is(parentPath, selectionPath))) {
            var parentTitle = parent.getIn(['atts', 'section_title']) || this.props.moduleOptions.getIn([parent.get('name'), 'title']);
            document.getElementById('tatsu-preview').contentWindow.postMessage('hover_set,' + parent.get('id') + ',' + parentTitle + ',' + parent.get('name'), '*');
        }
    },

getRowWrapperClass: function getRowWrapperClass(atts, row) {

return rowWrapperClass;
    },

setCurDraggingCol: function setCurDraggingCol(indexArray) {
        this.setState({
            curDraggingCols: indexArray
        });
    },

resetCurDraggingCol: function resetCurDraggingCol() {
        this.setState({
            curDraggingCols: []
        });
    },

render: function render() {

var path = this.props.path,
            row = this.props.row,
            targetDisplay = this.props.targetDisplay,
            idString = row.get('id'),
            children = row.get('inner'),
            rowStyle = {},
            atts = row.get('atts'),
            pathFromSelectionState = this.props.pathFromSelectionState,
            dropEffect = this.props.dropEffect,
            fullWidthRow = atts.get('full_width'),
            title = row.get('name'),
            moduleName = row.get('name'),
            moduleOptions = this.props.moduleOptions,
            attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']),
            atts = getAttsBasedOnTargetDisplay(row.get('atts'), targetDisplay, attsFromModuleOptions),
            moduleStyles = getModuleStyle(row, targetDisplay, moduleOptions),
            cssObject = getConcatenatedCSS(moduleStyles),
            gutterValue,
            moduleOptions = this.props.moduleOptions,
            rowWrapperClass = this.getRowWrapperClass(atts, row),
            customRowClass = 'string' === typeof atts.get('row_class') && '' != atts.get('row_class') ? atts.get('row_class') : '',
            customRowId = 'string' === typeof atts.get('row_id') && '' != atts.get('row_id') ? atts.get('row_id') : null;

var tempStyles = jQuery.extend({}, cssObject.style['> .tatsu-row']);
        if (tempStyles.hasOwnProperty('marginTop')) {

if (tempStyles.marginTop.split(" ").length) {
                var tempMargins = tempStyles.marginTop;
                tempStyles.marginTop = tempMargins.split(" ")[0];
                tempStyles.marginBottom = tempMargins.split(" ")[1];
            }
        }

var rowWrapStyle = jQuery.extend({}, cssObject.style['.tatsu-row-wrap'], cssObject.style['root']),
            rowStyleCSS = jQuery.extend({}, cssObject.style['.tatsu-row-wrap > .tatsu-row'], tempStyles);

if ('custom' === atts.get('gutter')) {
            gutterValue = atts.get('column_spacing') || '0';
            gutterValue = Number(gutterValue.replace('px', '')) / 2;
            gutterValue = gutterValue + 'px';
        }
        if ('undefined' != typeof gutterValue && !isEmpty(fullWidthRow)) {
            rowStyle.margin = '0 ' + gutterValue;
        } else if ('undefined' != typeof gutterValue && 'undefined' != typeof fullWidthRow) {
            rowStyle.margin = '0 -' + gutterValue;
        }
        rowStyle = jQuery.extend({}, rowStyle, rowStyleCSS);

return React.createElement(
            'div',
            { onContextMenu: 2 == path.size ? this.handleRightClick : null, className: "tatsu-row-wrap be-preview tatsu-clearfix " + rowWrapperClass + "be-pb-observer-" + idString + " ", onMouseEnter: 2 == path.size ? this.mouseEnterHandler : null, onMouseLeave: 2 == path.size ? this.mouseLeaveHandler : null, onClick: 2 == path.size ? routeHandler.bind(null, path) : null, style: rowWrapStyle },
            React.createElement(
                'div',
                { className: "tatsu-row " + customRowClass, style: rowStyle, id: customRowId },
                children.map(function (column, index) {
                    var columnPath = path,
                        widthDraggerPlaceholderPosition = false;
                    columnPath = columnPath.push(children.indexOf(column));
                    if (-1 < this.state.curDraggingCols.indexOf(index)) {
                        widthDraggerPlaceholderPosition = 0 === this.state.curDraggingCols.indexOf(index) ? 'right' : 'left';
                    }
                    return React.createElement(Column, { widthDraggerPlaceholderPosition: widthDraggerPlaceholderPosition, pathFromSelectionState: pathFromSelectionState, dropEffect: dropEffect, key: column.get('id'), targetDisplay: targetDisplay, setCurDraggingCol: this.setCurDraggingCol, resetCurDraggingCol: this.resetCurDraggingCol, path: columnPath, column: column, parent: row, moduleOptions: moduleOptions });
                }.bind(this))
            )
        );
    }

});

module.exports = Row;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 157 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

function NextArrow(props) {
    var onClick = props.onClick;
    return React.createElement("div", {
        className: "tatsu-slick-arrow tatsu-next",
        onClick: onClick,
        dangerouslySetInnerHTML: { __html: null != tatsuConfig.slider_icons && tatsuConfig.slider_icons.right }
    });
}

function PrevArrow(props) {
    var onClick = props.onClick;
    return React.createElement("div", {
        className: "tatsu-slick-arrow tatsu-prev",
        onClick: onClick,
        dangerouslySetInnerHTML: { __html: null != tatsuConfig.slider_icons && tatsuConfig.slider_icons.left }
    });
}

module.exports = { NextArrow: NextArrow, PrevArrow: PrevArrow };
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 158 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function smartSearch(fullString, searchKey, delimeter) {
  if (typeof fullString !== "string" || !searchKey) {
    return false;
  }
  delimeter = delimeter || ' ';
  var tempArray = fullString.split(delimeter);
  return tempArray.some(function (i) {
    return i.toLowerCase().startsWith(searchKey.toLowerCase());
  });
};

/***/ }),
/* 159 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var Immutable = __webpack_require__(3),
    shortid = __webpack_require__(116);

var ModelObject = function ModelObject() {

this.model = Immutable.Map();
};

ModelObject.prototype.setName = function (argName) {
	this.model = this.model.set('name', argName);
};

ModelObject.prototype.setTitle = function (argName, moduleOptions) {

var title = moduleOptions.getIn([argName, 'title']);
	if ('undefined' === typeof title || 'string' != typeof title) {
		title = 'Module';
	}
	this.model = this.model.set('title', title);
};

ModelObject.prototype.setAtts = function (argName, moduleOptions) {

var atts = Immutable.OrderedMap(),
	    attsFromModuleOptions = moduleOptions.getIn([argName, 'atts']),
	    preset = moduleOptions.getIn([argName, 'presets', 'default', 'preset']);
	if (!Immutable.List.isList(attsFromModuleOptions)) {
		attsFromModuleOptions = Immutable.List();
	}
	attsFromModuleOptions.forEach(function (att, index) {

var attName = att.get('att_name'),
		    options,
		    addUnitToValue,
		    unit,
		    defaultValue = att.get('default'),
		    presetValue = preset && preset.has(attName) ? preset.get(attName) : '';

if ('undefined' == typeof defaultValue) {
			defaultValue = '';
		}
		if ('number' == typeof defaultValue) {
			defaultValue = defaultValue.toString();
		}
		if ('string' === typeof defaultValue && ('slider' === att.get('type') || 'number' === att.get('type'))) {
			options = att.get('options');
			if (Immutable.Map.isMap(options)) {
				addUnitToValue = options.get('add_unit_to_value') || false;
				unit = options.get('unit');
				if ('string' == typeof unit && addUnitToValue) {
					defaultValue = defaultValue + unit;
				}
			}
		}
		// Modify Default and Preset values if Responsive Control is enabled
		if (att.get('responsive')) {
			if (!Immutable.Map.isMap(defaultValue)) {
				defaultValue = Immutable.Map({
					'd': defaultValue,
					'l': null,
					't': null,
					'm': null
				});
			}
			if ('' !== presetValue && !Immutable.Map.isMap(presetValue)) {
				presetValue = Immutable.Map({
					'd': presetValue,
					'l': null,
					't': null,
					'm': null
				});
				preset = preset.set(attName, presetValue);
			}
		}
		atts = atts.set(attName, defaultValue);
	});
	atts = atts.merge(preset);
	if ('tatsu_row' === argName || 'tatsu_column' === argName || 'tatsu_inner_row' === argName || 'tatsu_inner_column' === argName) {
		atts = atts.set('layout', '1/1');
	}
	if ('tatsu_column' === argName || 'tatsu_inner_column' === argName) {
		atts = atts.set('column_width', Immutable.Map({ 'd': 100, 'l': 100, 't': 100, 'm': 100 }));
	}
	if ('tatsu_header_row' === argName) {
		atts = atts.set('layout', '1/4+3/4');
	}
	if ('tatsu_header_column' === argName || 'tatsu_slide_menu_column' === argName) {
		atts = atts.set('layout', '1/2');
		// atts = atts.set( 'column_width', Immutable.Map( { 'd' : 50, 'l' : 50, 't' : 50, 'm' : 50 } ) );
	}
	this.model = this.model.set('atts', atts);
};

ModelObject.prototype.setChildModule = function (argName, moduleOptions) {

var childModule = moduleOptions.getIn([argName, 'child_module']);
	if ('undefined' != typeof childModule && 'string' === typeof childModule) {
		this.model = this.model.set('childModule', childModule);
	}
};

ModelObject.prototype.setContent = function (argName, moduleOptions) {

var moduleAttributes = moduleOptions.getIn([argName, 'atts']) || Immutable.List(),
	    content = '',
	    type = moduleOptions.getIn([argName, 'type']);
	if ('undefined' != typeof type && 'core' != type) {
		content = this.model.getIn(['atts', 'content']);
		content = null == content ? '' : content;
		this.model = this.model.set('content', content);
	}
};

ModelObject.prototype.setInner = function (argName, moduleOptions) {

var type = moduleOptions.getIn([argName, 'type']) || '',
	    inner = Immutable.List();
	if ('multi' === type || 'core' === type) {
		var children = moduleOptions.getIn([argName, 'child_module']),
		    initialChildrenCount = 'undefined' == typeof moduleOptions.getIn([argName, 'initial_children']) ? 1 : moduleOptions.getIn([argName, 'initial_children']);
		if ('string' === typeof children || Immutable.List.isList(children)) {
			if (Immutable.List.isList(children)) {
				children.forEach(function (child, index) {

for (var i = 0; i < initialChildrenCount; i++) {
						inner = inner.push(this.getModuleMap(child, moduleOptions));
					}
				}.bind(this));
			} else {
				for (var i = 0; i < initialChildrenCount; i++) {
					inner = inner.push(this.getModuleMap(children, moduleOptions));
				}
			}
		} else {
			console.log('child_module can only be a string or array!');
		}
	}
	this.model = this.model.set('inner', inner);
};

ModelObject.prototype.setBuilderLayout = function (argName, moduleOptions) {

var builderLayout = moduleOptions.getIn([argName, 'builder_layout']) || 'list',
	    allowedBuilderLayouts = "list,column";

if ('undefined' != typeof builderLayout && 'string' === typeof builderLayout && -1 < allowedBuilderLayouts.indexOf(builderLayout)) {
		this.model = this.model.set('builderLayout', builderLayout);
	}
};

ModelObject.prototype.setType = function (argName, moduleOptions) {

var type = moduleOptions.getIn([argName, 'type']),
	    allowedType = 'core,single,multi,sub_module';
	if ('undefined' === typeof type || 'string' != typeof type || -1 === allowedType.indexOf(type)) {
		type = 'single';
	} else {
		this.model = this.model.set('type', type);
	}
};

ModelObject.prototype.setShortcodeOutput = function (argName, moduleOptions) {

var type = moduleOptions.getIn([argName, 'type']),
	    requiredType = 'multi,single';
	if ('undefined' != typeof type && -1 < requiredType.indexOf(type)) {
		this.model = this.model.set('shortcode_output', '');
	}
};

ModelObject.prototype.setId = function () {

// this.model = this.model.set( 'id', uuid.v4() );
	this.model = this.model.set('id', shortid.generate());
};

ModelObject.prototype.getModuleMap = function (argName, moduleOptions) {

this.setInner(argName, moduleOptions);
	this.setId();
	this.setName(argName);
	this.setType(argName, moduleOptions);
	this.setTitle(argName, moduleOptions);
	this.setAtts(argName, moduleOptions);
	this.setBuilderLayout(argName, moduleOptions);
	this.setChildModule(argName, moduleOptions);
	this.setShortcodeOutput(argName, moduleOptions);
	return this.model;
};

module.exports = ModelObject;

/***/ }),
/* 160 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _from = __webpack_require__(777);

var _from2 = _interopRequireDefault(_from);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = function (arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
      arr2[i] = arr[i];
    }

return arr2;
  } else {
    return (0, _from2.default)(arr);
  }
};

/***/ }),
/* 161 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _iterator = __webpack_require__(784);

var _iterator2 = _interopRequireDefault(_iterator);

var _symbol = __webpack_require__(783);

var _symbol2 = _interopRequireDefault(_symbol);

var _typeof = typeof _symbol2.default === "function" && typeof _iterator2.default === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj; };

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = typeof _symbol2.default === "function" && _typeof(_iterator2.default) === "symbol" ? function (obj) {
  return typeof obj === "undefined" ? "undefined" : _typeof(obj);
} : function (obj) {
  return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
};

/***/ }),
/* 162 */
/***/ (function(module, exports) {

module.exports = true;

/***/ }),
/* 163 */
/***/ (function(module, exports) {

exports.f = {}.propertyIsEnumerable;

/***/ }),
/* 164 */
/***/ (function(module, exports) {

var id = 0;
var px = Math.random();
module.exports = function (key) {
  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
};

/***/ }),
/* 165 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.END_DRAG = exports.DROP = exports.HOVER = exports.PUBLISH_DRAG_SOURCE = exports.BEGIN_DRAG = undefined;

exports.beginDrag = beginDrag;
exports.publishDragSource = publishDragSource;
exports.hover = hover;
exports.drop = drop;
exports.endDrag = endDrag;

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _isArray = __webpack_require__(27);

var _isArray2 = _interopRequireDefault(_isArray);

var _isObject = __webpack_require__(46);

var _isObject2 = _interopRequireDefault(_isObject);

var _matchesType = __webpack_require__(401);

var _matchesType2 = _interopRequireDefault(_matchesType);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var BEGIN_DRAG = exports.BEGIN_DRAG = 'dnd-core/BEGIN_DRAG';
var PUBLISH_DRAG_SOURCE = exports.PUBLISH_DRAG_SOURCE = 'dnd-core/PUBLISH_DRAG_SOURCE';
var HOVER = exports.HOVER = 'dnd-core/HOVER';
var DROP = exports.DROP = 'dnd-core/DROP';
var END_DRAG = exports.END_DRAG = 'dnd-core/END_DRAG';

function beginDrag(sourceIds) {
	var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { publishSource: true, clientOffset: null };
	var publishSource = options.publishSource,
	    clientOffset = options.clientOffset,
	    getSourceClientOffset = options.getSourceClientOffset;

(0, _invariant2.default)((0, _isArray2.default)(sourceIds), 'Expected sourceIds to be an array.');

var monitor = this.getMonitor();
	var registry = this.getRegistry();
	(0, _invariant2.default)(!monitor.isDragging(), 'Cannot call beginDrag while dragging.');

for (var i = 0; i < sourceIds.length; i++) {
		(0, _invariant2.default)(registry.getSource(sourceIds[i]), 'Expected sourceIds to be registered.');
	}

var sourceClientOffset = null;
	if (clientOffset) {
		(0, _invariant2.default)(typeof getSourceClientOffset === 'function', 'When clientOffset is provided, getSourceClientOffset must be a function.');
		sourceClientOffset = getSourceClientOffset(sourceId);
	}

var source = registry.getSource(sourceId);
	var item = source.beginDrag(monitor, sourceId);
	(0, _invariant2.default)((0, _isObject2.default)(item), 'Item must be an object.');

registry.pinSource(sourceId);

var itemType = registry.getSourceType(sourceId);
	return {
		type: BEGIN_DRAG,
		itemType: itemType,
		item: item,
		sourceId: sourceId,
		clientOffset: clientOffset,
		sourceClientOffset: sourceClientOffset,
		isSourcePublic: publishSource
	};
}

function publishDragSource() {
	var monitor = this.getMonitor();
	if (!monitor.isDragging()) {
		return;
	}

return { type: PUBLISH_DRAG_SOURCE };
}

function hover(targetIdsArg) {
	var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
	    _ref$clientOffset = _ref.clientOffset,
	    clientOffset = _ref$clientOffset === undefined ? null : _ref$clientOffset;

(0, _invariant2.default)((0, _isArray2.default)(targetIdsArg), 'Expected targetIds to be an array.');
	var targetIds = targetIdsArg.slice(0);

var monitor = this.getMonitor();
	var registry = this.getRegistry();
	(0, _invariant2.default)(monitor.isDragging(), 'Cannot call hover while not dragging.');
	(0, _invariant2.default)(!monitor.didDrop(), 'Cannot call hover after drop.');

// First check invariants.
	for (var i = 0; i < targetIds.length; i++) {
		var targetId = targetIds[i];
		(0, _invariant2.default)(targetIds.lastIndexOf(targetId) === i, 'Expected targetIds to be unique in the passed array.');

var target = registry.getTarget(targetId);
		(0, _invariant2.default)(target, 'Expected targetIds to be registered.');
	}

var draggedItemType = monitor.getItemType();

// Remove those targetIds that don't match the targetType.  This
	// fixes shallow isOver which would only be non-shallow because of
	// non-matching targets.
	for (var _i2 = targetIds.length - 1; _i2 >= 0; _i2--) {
		var _targetId = targetIds[_i2];
		var targetType = registry.getTargetType(_targetId);
		if (!(0, _matchesType2.default)(targetType, draggedItemType)) {
			targetIds.splice(_i2, 1);
		}
	}

// Finally call hover on all matching targets.
	for (var _i3 = 0; _i3 < targetIds.length; _i3++) {
		var _targetId2 = targetIds[_i3];
		var _target = registry.getTarget(_targetId2);
		_target.hover(monitor, _targetId2);
	}

return {
		type: HOVER,
		targetIds: targetIds,
		clientOffset: clientOffset
	};
}

function drop() {
	var _this = this;

var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

var monitor = this.getMonitor();
	var registry = this.getRegistry();
	(0, _invariant2.default)(monitor.isDragging(), 'Cannot call drop while not dragging.');
	(0, _invariant2.default)(!monitor.didDrop(), 'Cannot call drop twice during one drag operation.');

var targetIds = monitor.getTargetIds().filter(monitor.canDropOnTarget, monitor);

targetIds.reverse();
	targetIds.forEach(function (targetId, index) {
		var target = registry.getTarget(targetId);

var dropResult = target.drop(monitor, targetId);
		(0, _invariant2.default)(typeof dropResult === 'undefined' || (0, _isObject2.default)(dropResult), 'Drop result must either be an object or undefined.');
		if (typeof dropResult === 'undefined') {
			dropResult = index === 0 ? {} : monitor.getDropResult();
		}

_this.store.dispatch({
			type: DROP,
			dropResult: _extends({}, options, dropResult)
		});
	});
}

function endDrag() {
	var monitor = this.getMonitor();
	var registry = this.getRegistry();
	(0, _invariant2.default)(monitor.isDragging(), 'Cannot call endDrag while not dragging.');

var sourceId = monitor.getSourceId();
	var source = registry.getSource(sourceId, true);
	source.endDrag(monitor, sourceId);

registry.unpinSource();

return { type: END_DRAG };
}

/***/ }),
/* 166 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.addSource = addSource;
exports.addTarget = addTarget;
exports.removeSource = removeSource;
exports.removeTarget = removeTarget;
var ADD_SOURCE = exports.ADD_SOURCE = 'dnd-core/ADD_SOURCE';
var ADD_TARGET = exports.ADD_TARGET = 'dnd-core/ADD_TARGET';
var REMOVE_SOURCE = exports.REMOVE_SOURCE = 'dnd-core/REMOVE_SOURCE';
var REMOVE_TARGET = exports.REMOVE_TARGET = 'dnd-core/REMOVE_TARGET';

function addSource(sourceId) {
	return {
		type: ADD_SOURCE,
		sourceId: sourceId
	};
}

function addTarget(targetId) {
	return {
		type: ADD_TARGET,
		targetId: targetId
	};
}

function removeSource(sourceId) {
	return {
		type: REMOVE_SOURCE,
		sourceId: sourceId
	};
}

function removeTarget(targetId) {
	return {
		type: REMOVE_TARGET,
		targetId: targetId
	};
}

/***/ }),
/* 167 */
/***/ (function(module, exports, __webpack_require__) {

var invariant = __webpack_require__(19);

/**
 * Constructs an enumeration with keys equal to their value.
 *
 * For example:
 *
 *   var COLORS = keyMirror({blue: null, red: null});
 *   var myColor = COLORS.blue;
 *   var isColorValid = !!COLORS[myColor];
 *
 * The last line could not be performed if the values of the generated enum were
 * not equal to their keys.
 *
 *   Input:  {key1: val1, key2: val2}
 *   Output: {key1: key1, key2: key2}
 *
 * @param {object} obj
 * @return {object}
 */
var keyMirror = function keyMirror(obj) {
  var ret = {};
  var key;
  !(obj instanceof Object && !Array.isArray(obj)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'keyMirror(...): Argument must be an object.') : invariant(false) : void 0;
  for (key in obj) {
    if (!obj.hasOwnProperty(key)) {
      continue;
    }
    ret[key] = key;
  }
  return ret;
};

module.exports = keyMirror;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 168 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @typechecks
 * 
 */

/*eslint-disable no-self-compare */

var hasOwnProperty = Object.prototype.hasOwnProperty;

/**
 * inlined Object.is polyfill to avoid requiring consumers ship their own
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
 */
function is(x, y) {
  // SameValue algorithm
  if (x === y) {
    // Steps 1-5, 7-10
    // Steps 6.b-6.e: +0 != -0
    // Added the nonzero y check to make Flow happy, but it is redundant
    return x !== 0 || y !== 0 || 1 / x === 1 / y;
  } else {
    // Step 6.a: NaN == NaN
    return x !== x && y !== y;
  }
}

/**
 * Performs equality by iterating through keys on an object and returning false
 * when any key has values which are not strictly equal between the arguments.
 * Returns true when the values of all keys are strictly equal.
 */
function shallowEqual(objA, objB) {
  if (is(objA, objB)) {
    return true;
  }

if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
    return false;
  }

var keysA = Object.keys(objA);
  var keysB = Object.keys(objB);

if (keysA.length !== keysB.length) {
    return false;
  }

// Test for A's keys different from B.
  for (var i = 0; i < keysA.length; i++) {
    if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
      return false;
    }
  }

return true;
}

module.exports = shallowEqual;

/***/ }),
/* 169 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
exports.canUseDOM = canUseDOM;

/***/ }),
/* 170 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

var _queryString = __webpack_require__(952);

var _runTransitionHook = __webpack_require__(269);

var _runTransitionHook2 = _interopRequireDefault(_runTransitionHook);

var _PathUtils = __webpack_require__(83);

var _deprecate = __webpack_require__(268);

var _deprecate2 = _interopRequireDefault(_deprecate);

var SEARCH_BASE_KEY = '$searchBase';

function defaultStringifyQuery(query) {
  return _queryString.stringify(query).replace(/%20/g, '+');
}

var defaultParseQueryString = _queryString.parse;

function isNestedObject(object) {
  for (var p in object) {
    if (Object.prototype.hasOwnProperty.call(object, p) && typeof object[p] === 'object' && !Array.isArray(object[p]) && object[p] !== null) return true;
  }return false;
}

/**
 * Returns a new createHistory function that may be used to create
 * history objects that know how to handle URL queries.
 */
function useQueries(createHistory) {
  return function () {
    var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

var history = createHistory(options);

var stringifyQuery = options.stringifyQuery;
    var parseQueryString = options.parseQueryString;

if (typeof stringifyQuery !== 'function') stringifyQuery = defaultStringifyQuery;

if (typeof parseQueryString !== 'function') parseQueryString = defaultParseQueryString;

function addQuery(location) {
      if (location.query == null) {
        var search = location.search;

location.query = parseQueryString(search.substring(1));
        location[SEARCH_BASE_KEY] = { search: search, searchBase: '' };
      }

// TODO: Instead of all the book-keeping here, this should just strip the
      // stringified query from the search.

return location;
    }

function appendQuery(location, query) {
      var _extends2;

var searchBaseSpec = location[SEARCH_BASE_KEY];
      var queryString = query ? stringifyQuery(query) : '';
      if (!searchBaseSpec && !queryString) {
        return location;
      }

process.env.NODE_ENV !== 'production' ? _warning2['default'](stringifyQuery !== defaultStringifyQuery || !isNestedObject(query), 'useQueries does not stringify nested query objects by default; ' + 'use a custom stringifyQuery function') : undefined;

if (typeof location === 'string') location = _PathUtils.parsePath(location);

var searchBase = undefined;
      if (searchBaseSpec && location.search === searchBaseSpec.search) {
        searchBase = searchBaseSpec.searchBase;
      } else {
        searchBase = location.search || '';
      }

var search = searchBase;
      if (queryString) {
        search += (search ? '&' : '?') + queryString;
      }

return _extends({}, location, (_extends2 = {
        search: search
      }, _extends2[SEARCH_BASE_KEY] = { search: search, searchBase: searchBase }, _extends2));
    }

// Override all read methods with query-aware versions.
    function listenBefore(hook) {
      return history.listenBefore(function (location, callback) {
        _runTransitionHook2['default'](hook, addQuery(location), callback);
      });
    }

function listen(listener) {
      return history.listen(function (location) {
        listener(addQuery(location));
      });
    }

// Override all write methods with query-aware versions.
    function push(location) {
      history.push(appendQuery(location, location.query));
    }

function replace(location) {
      history.replace(appendQuery(location, location.query));
    }

function createPath(location, query) {
      process.env.NODE_ENV !== 'production' ? _warning2['default'](!query, 'the query argument to createPath is deprecated; use a location descriptor instead') : undefined;

return history.createPath(appendQuery(location, query || location.query));
    }

function createHref(location, query) {
      process.env.NODE_ENV !== 'production' ? _warning2['default'](!query, 'the query argument to createHref is deprecated; use a location descriptor instead') : undefined;

return history.createHref(appendQuery(location, query || location.query));
    }

function createLocation(location) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

var fullLocation = history.createLocation.apply(history, [appendQuery(location, location.query)].concat(args));
      if (location.query) {
        fullLocation.query = location.query;
      }
      return addQuery(fullLocation);
    }

// deprecated
    function pushState(state, path, query) {
      if (typeof path === 'string') path = _PathUtils.parsePath(path);

push(_extends({ state: state }, path, { query: query }));
    }

// deprecated
    function replaceState(state, path, query) {
      if (typeof path === 'string') path = _PathUtils.parsePath(path);

replace(_extends({ state: state }, path, { query: query }));
    }

return _extends({}, history, {
      listenBefore: listenBefore,
      listen: listen,
      push: push,
      replace: replace,
      createPath: createPath,
      createHref: createHref,
      createLocation: createLocation,

pushState: _deprecate2['default'](pushState, 'pushState is deprecated; use push instead'),
      replaceState: _deprecate2['default'](replaceState, 'replaceState is deprecated; use replace instead')
    });
  };
}

exports['default'] = useQueries;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 171 */
/***/ (function(module, exports, __webpack_require__) {

var listCacheClear = __webpack_require__(1040),
    listCacheDelete = __webpack_require__(1041),
    listCacheGet = __webpack_require__(1042),
    listCacheHas = __webpack_require__(1043),
    listCacheSet = __webpack_require__(1044);

/**
 * Creates an list cache object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function ListCache(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

// Add methods to `ListCache`.
ListCache.prototype.clear = listCacheClear;
ListCache.prototype['delete'] = listCacheDelete;
ListCache.prototype.get = listCacheGet;
ListCache.prototype.has = listCacheHas;
ListCache.prototype.set = listCacheSet;

module.exports = ListCache;

/***/ }),
/* 172 */
/***/ (function(module, exports, __webpack_require__) {

var MapCache = __webpack_require__(273),
    setCacheAdd = __webpack_require__(1058),
    setCacheHas = __webpack_require__(1059);

/**
 *
 * Creates an array cache object to store unique values.
 *
 * @private
 * @constructor
 * @param {Array} [values] The values to cache.
 */
function SetCache(values) {
  var index = -1,
      length = values == null ? 0 : values.length;

this.__data__ = new MapCache;
  while (++index < length) {
    this.add(values[index]);
  }
}

// Add methods to `SetCache`.
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
SetCache.prototype.has = setCacheHas;

module.exports = SetCache;

/***/ }),
/* 173 */
/***/ (function(module, exports, __webpack_require__) {

var eq = __webpack_require__(136);

/**
 * Gets the index at which the `key` is found in `array` of key-value pairs.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} key The key to search for.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function assocIndexOf(array, key) {
  var length = array.length;
  while (length--) {
    if (eq(array[length][0], key)) {
      return length;
    }
  }
  return -1;
}

module.exports = assocIndexOf;

/***/ }),
/* 174 */
/***/ (function(module, exports) {

/**
 * Checks if a `cache` value for `key` exists.
 *
 * @private
 * @param {Object} cache The cache to query.
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function cacheHas(cache, key) {
  return cache.has(key);
}

module.exports = cacheHas;

/***/ }),
/* 175 */
/***/ (function(module, exports, __webpack_require__) {

var isArray = __webpack_require__(27),
    isKey = __webpack_require__(288),
    stringToPath = __webpack_require__(1068),
    toString = __webpack_require__(137);

/**
 * Casts `value` to a path array if it's not one.
 *
 * @private
 * @param {*} value The value to inspect.
 * @param {Object} [object] The object to query keys on.
 * @returns {Array} Returns the cast property path array.
 */
function castPath(value, object) {
  if (isArray(value)) {
    return value;
  }
  return isKey(value, object) ? [value] : stringToPath(toString(value));
}

module.exports = castPath;

/***/ }),
/* 176 */
/***/ (function(module, exports, __webpack_require__) {

var isKeyable = __webpack_require__(1037);

/**
 * Gets the data for `map`.
 *
 * @private
 * @param {Object} map The map to query.
 * @param {string} key The reference key.
 * @returns {*} Returns the map data.
 */
function getMapData(map, key) {
  var data = map.__data__;
  return isKeyable(key)
    ? data[typeof key == 'string' ? 'string' : 'hash']
    : data.map;
}

module.exports = getMapData;

/***/ }),
/* 177 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(85);

/* Built-in method references that are verified to be native. */
var nativeCreate = getNative(Object, 'create');

module.exports = nativeCreate;

/***/ }),
/* 178 */
/***/ (function(module, exports) {

/**
 * This method returns the first argument it receives.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Util
 * @param {*} value Any value.
 * @returns {*} Returns `value`.
 * @example
 *
 * var object = { 'a': 1 };
 *
 * console.log(_.identity(object) === object);
 * // => true
 */
function identity(value) {
  return value;
}

module.exports = identity;

/***/ }),
/* 179 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsArguments = __webpack_require__(980),
    isObjectLike = __webpack_require__(47);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Built-in value references. */
var propertyIsEnumerable = objectProto.propertyIsEnumerable;

/**
 * Checks if `value` is likely an `arguments` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
 *  else `false`.
 * @example
 *
 * _.isArguments(function() { return arguments; }());
 * // => true
 *
 * _.isArguments([1, 2, 3]);
 * // => false
 */
var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
    !propertyIsEnumerable.call(value, 'callee');
};

module.exports = isArguments;

/***/ }),
/* 180 */
/***/ (function(module, exports, __webpack_require__) {

var isArrayLike = __webpack_require__(73),
    isObjectLike = __webpack_require__(47);

/**
 * This method is like `_.isArrayLike` except that it also checks if `value`
 * is an object.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an array-like object,
 *  else `false`.
 * @example
 *
 * _.isArrayLikeObject([1, 2, 3]);
 * // => true
 *
 * _.isArrayLikeObject(document.body.children);
 * // => true
 *
 * _.isArrayLikeObject('abc');
 * // => false
 *
 * _.isArrayLikeObject(_.noop);
 * // => false
 */
function isArrayLikeObject(value) {
  return isObjectLike(value) && isArrayLike(value);
}

module.exports = isArrayLikeObject;

/***/ }),
/* 181 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(45),
    stubFalse = __webpack_require__(1093);

/** Detect free variable `exports`. */
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;

/** Built-in value references. */
var Buffer = moduleExports ? root.Buffer : undefined;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;

/**
 * Checks if `value` is a buffer.
 *
 * @static
 * @memberOf _
 * @since 4.3.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
 * @example
 *
 * _.isBuffer(new Buffer(2));
 * // => true
 *
 * _.isBuffer(new Uint8Array(2));
 * // => false
 */
var isBuffer = nativeIsBuffer || stubFalse;

module.exports = isBuffer;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(201)(module)))

/***/ }),
/* 182 */
/***/ (function(module, exports, __webpack_require__) {

var baseKeys = __webpack_require__(432),
    getTag = __webpack_require__(133),
    isArguments = __webpack_require__(179),
    isArray = __webpack_require__(27),
    isArrayLike = __webpack_require__(73),
    isBuffer = __webpack_require__(181),
    isPrototype = __webpack_require__(134),
    isTypedArray = __webpack_require__(294);

/** `Object#toString` result references. */
var mapTag = '[object Map]',
    setTag = '[object Set]';

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Checks if `value` is an empty object, collection, map, or set.
 *
 * Objects are considered empty if they have no own enumerable string keyed
 * properties.
 *
 * Array-like values such as `arguments` objects, arrays, buffers, strings, or
 * jQuery-like collections are considered empty if they have a `length` of `0`.
 * Similarly, maps and sets are considered empty if they have a `size` of `0`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is empty, else `false`.
 * @example
 *
 * _.isEmpty(null);
 * // => true
 *
 * _.isEmpty(true);
 * // => true
 *
 * _.isEmpty(1);
 * // => true
 *
 * _.isEmpty([1, 2, 3]);
 * // => false
 *
 * _.isEmpty({ 'a': 1 });
 * // => false
 */
function isEmpty(value) {
  if (value == null) {
    return true;
  }
  if (isArrayLike(value) &&
      (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
        isBuffer(value) || isTypedArray(value) || isArguments(value))) {
    return !value.length;
  }
  var tag = getTag(value);
  if (tag == mapTag || tag == setTag) {
    return !value.size;
  }
  if (isPrototype(value)) {
    return !baseKeys(value).length;
  }
  for (var key in value) {
    if (hasOwnProperty.call(value, key)) {
      return false;
    }
  }
  return true;
}

module.exports = isEmpty;

/***/ }),
/* 183 */
/***/ (function(module, exports, __webpack_require__) {

var baseGetTag = __webpack_require__(84),
    isObjectLike = __webpack_require__(47);

/** `Object#toString` result references. */
var symbolTag = '[object Symbol]';

/**
 * Checks if `value` is classified as a `Symbol` primitive or object.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
 * @example
 *
 * _.isSymbol(Symbol.iterator);
 * // => true
 *
 * _.isSymbol('abc');
 * // => false
 */
function isSymbol(value) {
  return typeof value == 'symbol' ||
    (isObjectLike(value) && baseGetTag(value) == symbolTag);
}

module.exports = isSymbol;

/***/ }),
/* 184 */
/***/ (function(module, exports, __webpack_require__) {

var arrayLikeKeys = __webpack_require__(425),
    baseKeysIn = __webpack_require__(989),
    isArrayLike = __webpack_require__(73);

/**
 * Creates an array of the own and inherited enumerable property names of `object`.
 *
 * **Note:** Non-object values are coerced to objects.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.keysIn(new Foo);
 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
 */
function keysIn(object) {
  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
}

module.exports = keysIn;

/***/ }),
/* 185 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.create = exports.connect = exports.Provider = undefined;

var _Provider2 = __webpack_require__(1101);

var _Provider3 = _interopRequireDefault(_Provider2);

var _connect2 = __webpack_require__(1102);

var _connect3 = _interopRequireDefault(_connect2);

var _create2 = __webpack_require__(1103);

var _create3 = _interopRequireDefault(_create2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.Provider = _Provider3.default;
exports.connect = _connect3.default;
exports.create = _create3.default;

/***/ }),
/* 186 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports['default'] = checkDecoratorArguments;

function checkDecoratorArguments(functionName, signature) {
  if (process.env.NODE_ENV !== 'production') {
    for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      args[_key - 2] = arguments[_key];
    }

for (var i = 0; i < args.length; i++) {
      var arg = args[i];
      if (arg && arg.prototype && arg.prototype.render) {
        console.error( // eslint-disable-line no-console
        'You seem to be applying the arguments in the wrong order. ' + ('It should be ' + functionName + '(' + signature + ')(Component), not the other way around. ') + 'Read more: http://gaearon.github.io/react-dnd/docs-troubleshooting.html#you-seem-to-be-applying-the-arguments-in-the-wrong-order');
        return;
      }
    }
  }
}

module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 187 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _deprecateObjectProperties = __webpack_require__(188);

var _deprecateObjectProperties2 = _interopRequireDefault(_deprecateObjectProperties);

var _getRouteParams = __webpack_require__(1258);

var _getRouteParams2 = _interopRequireDefault(_getRouteParams);

var _RouteUtils = __webpack_require__(75);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _React$PropTypes = _react2.default.PropTypes;
var array = _React$PropTypes.array;
var func = _React$PropTypes.func;
var object = _React$PropTypes.object;

/**
 * A <RouterContext> renders the component tree for a given router state
 * and sets the history object and the current location in context.
 */

var RouterContext = _react2.default.createClass({
  displayName: 'RouterContext',

propTypes: {
    history: object,
    router: object.isRequired,
    location: object.isRequired,
    routes: array.isRequired,
    params: object.isRequired,
    components: array.isRequired,
    createElement: func.isRequired
  },

getDefaultProps: function getDefaultProps() {
    return {
      createElement: _react2.default.createElement
    };
  },

childContextTypes: {
    history: object,
    location: object.isRequired,
    router: object.isRequired
  },

getChildContext: function getChildContext() {
    var _props = this.props;
    var router = _props.router;
    var history = _props.history;
    var location = _props.location;

if (!router) {
      process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, '`<RouterContext>` expects a `router` rather than a `history`') : void 0;

router = _extends({}, history, {
        setRouteLeaveHook: history.listenBeforeLeavingRoute
      });
      delete router.listenBeforeLeavingRoute;
    }

if (process.env.NODE_ENV !== 'production') {
      location = (0, _deprecateObjectProperties2.default)(location, '`context.location` is deprecated, please use a route component\'s `props.location` instead. http://tiny.cc/router-accessinglocation');
    }

return { history: history, location: location, router: router };
  },
  createElement: function createElement(component, props) {
    return component == null ? null : this.props.createElement(component, props);
  },
  render: function render() {
    var _this = this;

var _props2 = this.props;
    var history = _props2.history;
    var location = _props2.location;
    var routes = _props2.routes;
    var params = _props2.params;
    var components = _props2.components;

var element = null;

if (components) {
      element = components.reduceRight(function (element, components, index) {
        if (components == null) return element; // Don't create new children; use the grandchildren.

var route = routes[index];
        var routeParams = (0, _getRouteParams2.default)(route, params);
        var props = {
          history: history,
          location: location,
          params: params,
          route: route,
          routeParams: routeParams,
          routes: routes
        };

if ((0, _RouteUtils.isReactChildren)(element)) {
          props.children = element;
        } else if (element) {
          for (var prop in element) {
            if (Object.prototype.hasOwnProperty.call(element, prop)) props[prop] = element[prop];
          }
        }

if ((typeof components === 'undefined' ? 'undefined' : _typeof(components)) === 'object') {
          var elements = {};

for (var key in components) {
            if (Object.prototype.hasOwnProperty.call(components, key)) {
              // Pass through the key as a prop to createElement to allow
              // custom createElement functions to know which named component
              // they're rendering, for e.g. matching up to fetched data.
              elements[key] = _this.createElement(components[key], _extends({
                key: key }, props));
            }
          }

return elements;
        }

return _this.createElement(components, props);
      }, element);
    }

!(element === null || element === false || _react2.default.isValidElement(element)) ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, 'The root route must render a single element') : (0, _invariant2.default)(false) : void 0;

return element;
  }
});

exports.default = RouterContext;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 188 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.canUseMembrane = undefined;

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var canUseMembrane = exports.canUseMembrane = false;

// No-op by default.
var deprecateObjectProperties = function deprecateObjectProperties(object) {
  return object;
};

if (process.env.NODE_ENV !== 'production') {
  try {
    if (Object.defineProperty({}, 'x', {
      get: function get() {
        return true;
      }
    }).x) {
      exports.canUseMembrane = canUseMembrane = true;
    }
    /* eslint-disable no-empty */
  } catch (e) {}
  /* eslint-enable no-empty */

if (canUseMembrane) {
    deprecateObjectProperties = function deprecateObjectProperties(object, message) {
      // Wrap the deprecated object in a membrane to warn on property access.
      var membrane = {};

var _loop = function _loop(prop) {
        if (!Object.prototype.hasOwnProperty.call(object, prop)) {
          return 'continue';
        }

if (typeof object[prop] === 'function') {
          // Can't use fat arrow here because of use of arguments below.
          membrane[prop] = function () {
            process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, message) : void 0;
            return object[prop].apply(object, arguments);
          };
          return 'continue';
        }

// These properties are non-enumerable to prevent React dev tools from
        // seeing them and causing spurious warnings when accessing them. In
        // principle this could be done with a proxy, but support for the
        // ownKeys trap on proxies is not universal, even among browsers that
        // otherwise support proxies.
        Object.defineProperty(membrane, prop, {
          get: function get() {
            process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, message) : void 0;
            return object[prop];
          }
        });
      };

for (var prop in object) {
        var _ret = _loop(prop);

if (_ret === 'continue') continue;
      }

return membrane;
    };
  }
}

exports.default = deprecateObjectProperties;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 189 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.canUseDOM = exports.slidesOnLeft = exports.slidesOnRight = exports.siblingDirection = exports.getTotalSlides = exports.getPostClones = exports.getPreClones = exports.getTrackLeft = exports.getTrackAnimateCSS = exports.getTrackCSS = exports.checkSpecKeys = exports.getSlideCount = exports.checkNavigable = exports.getNavigableIndexes = exports.swipeEnd = exports.swipeMove = exports.swipeStart = exports.keyHandler = exports.changeSlide = exports.slideHandler = exports.initializedState = exports.extractObject = exports.canGoNext = exports.getSwipeDirection = exports.getHeight = exports.getWidth = exports.lazySlidesOnRight = exports.lazySlidesOnLeft = exports.lazyEndIndex = exports.lazyStartIndex = exports.getRequiredLazySlides = exports.getOnDemandLazySlides = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactDom = __webpack_require__(7);

var _reactDom2 = _interopRequireDefault(_reactDom);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// return list of slides that need to be present
var getRequiredLazySlides = exports.getRequiredLazySlides = function getRequiredLazySlides(spec) {
  var requiredSlides = [];
  var startIndex = lazyStartIndex(spec);
  var endIndex = lazyEndIndex(spec);
  for (var slideIndex = startIndex; slideIndex < endIndex; slideIndex++) {
    requiredSlides.push(slideIndex);
  }
  return requiredSlides;
};

// startIndex that needs to be present
var lazyStartIndex = exports.lazyStartIndex = function lazyStartIndex(spec) {
  return spec.currentSlide - lazySlidesOnLeft(spec);
};
var lazyEndIndex = exports.lazyEndIndex = function lazyEndIndex(spec) {
  return spec.currentSlide + lazySlidesOnRight(spec);
};
var lazySlidesOnLeft = exports.lazySlidesOnLeft = function lazySlidesOnLeft(spec) {
  return spec.centerMode ? Math.floor(spec.slidesToShow / 2) + (parseInt(spec.centerPadding) > 0 ? 1 : 0) : 0;
};
var lazySlidesOnRight = exports.lazySlidesOnRight = function lazySlidesOnRight(spec) {
  return spec.centerMode ? Math.floor((spec.slidesToShow - 1) / 2) + 1 + (parseInt(spec.centerPadding) > 0 ? 1 : 0) : spec.slidesToShow;
};

// get width of an element
var getWidth = exports.getWidth = function getWidth(elem) {
  return elem && elem.offsetWidth || 0;
};
var getHeight = exports.getHeight = function getHeight(elem) {
  return elem && elem.offsetHeight || 0;
};
var getSwipeDirection = exports.getSwipeDirection = function getSwipeDirection(touchObject) {
  var verticalSwiping = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

var xDist, yDist, r, swipeAngle;
  xDist = touchObject.startX - touchObject.curX;
  yDist = touchObject.startY - touchObject.curY;
  r = Math.atan2(yDist, xDist);
  swipeAngle = Math.round(r * 180 / Math.PI);
  if (swipeAngle < 0) {
    swipeAngle = 360 - Math.abs(swipeAngle);
  }
  if (swipeAngle <= 45 && swipeAngle >= 0 || swipeAngle <= 360 && swipeAngle >= 315) {
    return "left";
  }
  if (swipeAngle >= 135 && swipeAngle <= 225) {
    return "right";
  }
  if (verticalSwiping === true) {
    if (swipeAngle >= 35 && swipeAngle <= 135) {
      return "up";
    } else {
      return "down";
    }
  }

return "vertical";
};

// whether or not we can go next
var canGoNext = exports.canGoNext = function canGoNext(spec) {
  var canGo = true;
  if (!spec.infinite) {
    if (spec.centerMode && spec.currentSlide >= spec.slideCount - 1) {
      canGo = false;
    } else if (spec.slideCount <= spec.slidesToShow || spec.currentSlide >= spec.slideCount - spec.slidesToShow) {
      canGo = false;
    }
  }
  return canGo;
};

// given an object and a list of keys, return new object with given keys
var extractObject = exports.extractObject = function extractObject(spec, keys) {
  var newObject = {};
  keys.forEach(function (key) {
    return newObject[key] = spec[key];
  });
  return newObject;
};

// get initialized state
var initializedState = exports.initializedState = function initializedState(spec) {
  // spec also contains listRef, trackRef
  var slideCount = _react2.default.Children.count(spec.children);
  var listWidth = Math.ceil(getWidth(_reactDom2.default.findDOMNode(spec.listRef)));
  var trackWidth = Math.ceil(getWidth(_reactDom2.default.findDOMNode(spec.trackRef)));
  var slideWidth = void 0;
  if (!spec.vertical) {
    var centerPaddingAdj = spec.centerMode && parseInt(spec.centerPadding) * 2;
    if (typeof spec.centerPadding === "string" && spec.centerPadding.slice(-1) === "%") {
      centerPaddingAdj *= listWidth / 100;
    }
    slideWidth = Math.ceil((listWidth - centerPaddingAdj) / spec.slidesToShow);
  } else {
    slideWidth = listWidth;
  }
  var slideHeight = _reactDom2.default.findDOMNode(spec.listRef) && getHeight(_reactDom2.default.findDOMNode(spec.listRef).querySelector('[data-index="0"]'));
  var listHeight = slideHeight * spec.slidesToShow;
  var currentSlide = spec.currentSlide === undefined ? spec.initialSlide : spec.currentSlide;
  if (spec.rtl && spec.currentSlide === undefined) {
    currentSlide = slideCount - 1 - spec.initialSlide;
  }
  var lazyLoadedList = spec.lazyLoadedList || [];
  var slidesToLoad = getOnDemandLazySlides({ currentSlide: currentSlide, lazyLoadedList: lazyLoadedList }, spec);
  lazyLoadedList.concat(slidesToLoad);

var state = {
    slideCount: slideCount,
    slideWidth: slideWidth,
    listWidth: listWidth,
    trackWidth: trackWidth,
    currentSlide: currentSlide,
    slideHeight: slideHeight,
    listHeight: listHeight,
    lazyLoadedList: lazyLoadedList
  };

if (spec.autoplaying === null && spec.autoplay) {
    state["autoplaying"] = "playing";
  }

return state;
};

var slideHandler = exports.slideHandler = function slideHandler(spec) {
  var waitForAnimate = spec.waitForAnimate,
      animating = spec.animating,
      fade = spec.fade,
      infinite = spec.infinite,
      index = spec.index,
      slideCount = spec.slideCount,
      lazyLoadedList = spec.lazyLoadedList,
      lazyLoad = spec.lazyLoad,
      currentSlide = spec.currentSlide,
      centerMode = spec.centerMode,
      slidesToScroll = spec.slidesToScroll,
      slidesToShow = spec.slidesToShow,
      useCSS = spec.useCSS;

if (waitForAnimate && animating) return {};
  var animationSlide = index,
      finalSlide = void 0,
      animationLeft = void 0,
      finalLeft = void 0;
  var state = {},
      nextState = {};
  if (fade) {
    if (!infinite && (index < 0 || index >= slideCount)) return {};
    if (index < 0) {
      animationSlide = index + slideCount;
    } else if (index >= slideCount) {
      animationSlide = index - slideCount;
    }
    if (lazyLoad && lazyLoadedList.indexOf(animationSlide) < 0) {
      lazyLoadedList.push(animationSlide);
    }
    state = {
      animating: true,
      currentSlide: animationSlide,
      lazyLoadedList: lazyLoadedList
    };
    nextState = { animating: false };
  } else {
    finalSlide = animationSlide;
    if (animationSlide < 0) {
      finalSlide = animationSlide + slideCount;
      if (!infinite) finalSlide = 0;else if (slideCount % slidesToScroll !== 0) finalSlide = slideCount - slideCount % slidesToScroll;
    } else if (!canGoNext(spec) && animationSlide > currentSlide) {
      animationSlide = finalSlide = currentSlide;
    } else if (centerMode && animationSlide >= slideCount) {
      animationSlide = infinite ? slideCount : slideCount - 1;
      finalSlide = infinite ? 0 : slideCount - 1;
    } else if (animationSlide >= slideCount) {
      finalSlide = animationSlide - slideCount;
      if (!infinite) finalSlide = slideCount - slidesToShow;else if (slideCount % slidesToScroll !== 0) finalSlide = 0;
    }
    animationLeft = getTrackLeft(_extends({}, spec, { slideIndex: animationSlide }));
    finalLeft = getTrackLeft(_extends({}, spec, { slideIndex: finalSlide }));
    if (!infinite) {
      if (animationLeft === finalLeft) animationSlide = finalSlide;
      animationLeft = finalLeft;
    }
    lazyLoad && lazyLoadedList.concat(getOnDemandLazySlides(_extends({}, spec, { currentSlide: animationSlide })));
    if (!useCSS) {
      state = {
        currentSlide: finalSlide,
        trackStyle: getTrackCSS(_extends({}, spec, { left: finalLeft })),
        lazyLoadedList: lazyLoadedList
      };
    } else {
      state = {
        animating: true,
        currentSlide: finalSlide,
        trackStyle: getTrackAnimateCSS(_extends({}, spec, { left: animationLeft })),
        lazyLoadedList: lazyLoadedList
      };
      nextState = {
        animating: false,
        currentSlide: finalSlide,
        trackStyle: getTrackCSS(_extends({}, spec, { left: finalLeft })),
        swipeLeft: null
      };
    }
  }
  return { state: state, nextState: nextState };
};

var changeSlide = exports.changeSlide = function changeSlide(spec, options) {
  var indexOffset, previousInt, slideOffset, unevenOffset, targetSlide;
  var slidesToScroll = spec.slidesToScroll,
      slidesToShow = spec.slidesToShow,
      slideCount = spec.slideCount,
      currentSlide = spec.currentSlide,
      lazyLoad = spec.lazyLoad,
      infinite = spec.infinite;

unevenOffset = slideCount % slidesToScroll !== 0;
  indexOffset = unevenOffset ? 0 : (slideCount - currentSlide) % slidesToScroll;

if (options.message === "previous") {
    slideOffset = indexOffset === 0 ? slidesToScroll : slidesToShow - indexOffset;
    targetSlide = currentSlide - slideOffset;
    if (lazyLoad && !infinite) {
      previousInt = currentSlide - slideOffset;
      targetSlide = previousInt === -1 ? slideCount - 1 : previousInt;
    }
  } else if (options.message === "next") {
    slideOffset = indexOffset === 0 ? slidesToScroll : indexOffset;
    targetSlide = currentSlide + slideOffset;
    if (lazyLoad && !infinite) {
      targetSlide = (currentSlide + slidesToScroll) % slideCount + indexOffset;
    }
  } else if (options.message === "dots") {
    // Click on dots
    targetSlide = options.index * options.slidesToScroll;
    if (targetSlide === options.currentSlide) {
      return null;
    }
  } else if (options.message === "children") {
    // Click on the slides
    targetSlide = options.index;
    if (targetSlide === options.currentSlide) {
      return null;
    }
    if (infinite) {
      var direction = siblingDirection(_extends({}, spec, { targetSlide: targetSlide }));
      if (targetSlide > options.currentSlide && direction === "left") {
        targetSlide = targetSlide - slideCount;
      } else if (targetSlide < options.currentSlide && direction === "right") {
        targetSlide = targetSlide + slideCount;
      }
    }
  } else if (options.message === "index") {
    targetSlide = Number(options.index);
    if (targetSlide === options.currentSlide) {
      return null;
    }
  }
  return targetSlide;
};
var keyHandler = exports.keyHandler = function keyHandler(e, accessibility, rtl) {
  if (e.target.tagName.match("TEXTAREA|INPUT|SELECT") || !accessibility) return "";
  if (e.keyCode === 37) return rtl ? "next" : "previous";
  if (e.keyCode === 39) return rtl ? "previous" : "next";
  return "";
};

if (scrolling) return;
  if (animating) return e.preventDefault();
  if (vertical && swipeToSlide && verticalSwiping) e.preventDefault();
  var swipeLeft = void 0,
      state = {};
  var curLeft = getTrackLeft(spec);
  touchObject.curX = e.touches ? e.touches[0].pageX : e.clientX;
  touchObject.curY = e.touches ? e.touches[0].pageY : e.clientY;
  touchObject.swipeLength = Math.round(Math.sqrt(Math.pow(touchObject.curX - touchObject.startX, 2)));
  var verticalSwipeLength = Math.round(Math.sqrt(Math.pow(touchObject.curY - touchObject.startY, 2)));
  if (!verticalSwiping && !swiping && verticalSwipeLength > 10) {
    return { scrolling: true };
  }
  if (verticalSwiping) touchObject.swipeLength = verticalSwipeLength;
  var positionOffset = (!rtl ? 1 : -1) * (touchObject.curX > touchObject.startX ? 1 : -1);
  if (verticalSwiping) positionOffset = touchObject.curY > touchObject.startY ? 1 : -1;

if (!dragging) {
    if (swipe) e.preventDefault();
    return {};
  }
  var minSwipe = verticalSwiping ? listHeight / touchThreshold : listWidth / touchThreshold;
  var swipeDirection = getSwipeDirection(touchObject, verticalSwiping);
  // reset the state of touch related state variables.
  var state = {
    dragging: false,
    edgeDragged: false,
    scrolling: false,
    swiping: false,
    swiped: false,
    swipeLeft: null,
    touchObject: {}
  };
  if (scrolling) {
    return state;
  }
  if (!touchObject.swipeLength) {
    return state;
  }
  if (touchObject.swipeLength > minSwipe) {
    e.preventDefault();
    if (onSwipe) {
      onSwipe(swipeDirection);
    }
    var slideCount = void 0,
        newSlide = void 0;
    switch (swipeDirection) {
      case "left":
      case "up":
        newSlide = currentSlide + getSlideCount(spec);
        slideCount = swipeToSlide ? checkNavigable(spec, newSlide) : newSlide;
        state["currentDirection"] = 0;
        break;
      case "right":
      case "down":
        newSlide = currentSlide - getSlideCount(spec);
        slideCount = swipeToSlide ? checkNavigable(spec, newSlide) : newSlide;
        state["currentDirection"] = 1;
        break;
      default:
        slideCount = currentSlide;
    }
    state["triggerSlideHandler"] = slideCount;
  } else {
    // Adjust the track back to it's original position.
    var currentLeft = getTrackLeft(spec);
    state["trackStyle"] = getTrackAnimateCSS(_extends({}, spec, { left: currentLeft }));
  }
  return state;
};
var getNavigableIndexes = exports.getNavigableIndexes = function getNavigableIndexes(spec) {
  var max = spec.infinite ? spec.slideCount * 2 : spec.slideCount;
  var breakpoint = spec.infinite ? spec.slidesToShow * -1 : 0;
  var counter = spec.infinite ? spec.slidesToShow * -1 : 0;
  var indexes = [];
  while (breakpoint < max) {
    indexes.push(breakpoint);
    breakpoint = counter + spec.slidesToScroll;
    counter += Math.min(spec.slidesToScroll, spec.slidesToShow);
  }
  return indexes;
};
var checkNavigable = exports.checkNavigable = function checkNavigable(spec, index) {
  var navigables = getNavigableIndexes(spec);
  var prevNavigable = 0;
  if (index > navigables[navigables.length - 1]) {
    index = navigables[navigables.length - 1];
  } else {
    for (var n in navigables) {
      if (index < navigables[n]) {
        index = prevNavigable;
        break;
      }
      prevNavigable = navigables[n];
    }
  }
  return index;
};
var getSlideCount = exports.getSlideCount = function getSlideCount(spec) {
  var centerOffset = spec.centerMode ? spec.slideWidth * Math.floor(spec.slidesToShow / 2) : 0;
  if (spec.swipeToSlide) {
    var swipedSlide = void 0;
    var slickList = _reactDom2.default.findDOMNode(spec.listRef);
    var slides = slickList.querySelectorAll(".slick-slide");
    Array.from(slides).every(function (slide) {
      if (!spec.vertical) {
        if (slide.offsetLeft - centerOffset + getWidth(slide) / 2 > spec.swipeLeft * -1) {
          swipedSlide = slide;
          return false;
        }
      } else {
        if (slide.offsetTop + getHeight(slide) / 2 > spec.swipeLeft * -1) {
          swipedSlide = slide;
          return false;
        }
      }

return true;
    });

if (!swipedSlide) {
      return 0;
    }
    var currentIndex = spec.rtl === true ? spec.slideCount - spec.currentSlide : spec.currentSlide;
    var slidesTraversed = Math.abs(swipedSlide.dataset.index - currentIndex) || 1;
    return slidesTraversed;
  } else {
    return spec.slidesToScroll;
  }
};

var checkSpecKeys = exports.checkSpecKeys = function checkSpecKeys(spec, keysArray) {
  return keysArray.reduce(function (value, key) {
    return value && spec.hasOwnProperty(key);
  }, true) ? null : console.error("Keys Missing:", spec);
};

// Fallback for IE8
  if (window && !window.addEventListener && window.attachEvent) {
    if (!spec.vertical) {
      style.marginLeft = spec.left + "px";
    } else {
      style.marginTop = spec.left + "px";
    }
  }

return style;
};
var getTrackAnimateCSS = exports.getTrackAnimateCSS = function getTrackAnimateCSS(spec) {
  checkSpecKeys(spec, ["left", "variableWidth", "slideCount", "slidesToShow", "slideWidth", "speed", "cssEase"]);
  var style = getTrackCSS(spec);
  // useCSS is true by default so it can be undefined
  if (spec.useTransform) {
    style.WebkitTransition = "-webkit-transform " + spec.speed + "ms " + spec.cssEase;
    style.transition = "transform " + spec.speed + "ms " + spec.cssEase;
  } else {
    if (spec.vertical) {
      style.transition = "top " + spec.speed + "ms " + spec.cssEase;
    } else {
      style.transition = "left " + spec.speed + "ms " + spec.cssEase;
    }
  }
  return style;
};
var getTrackLeft = exports.getTrackLeft = function getTrackLeft(spec) {
  if (spec.unslick) {
    return 0;
  }

checkSpecKeys(spec, ["slideIndex", "trackRef", "infinite", "centerMode", "slideCount", "slidesToShow", "slidesToScroll", "slideWidth", "listWidth", "variableWidth", "slideHeight"]);

var slideIndex = spec.slideIndex,
      trackRef = spec.trackRef,
      infinite = spec.infinite,
      centerMode = spec.centerMode,
      slideCount = spec.slideCount,
      slidesToShow = spec.slidesToShow,
      slidesToScroll = spec.slidesToScroll,
      slideWidth = spec.slideWidth,
      listWidth = spec.listWidth,
      variableWidth = spec.variableWidth,
      slideHeight = spec.slideHeight,
      fade = spec.fade,
      vertical = spec.vertical;

var slideOffset = 0;
  var targetLeft;
  var targetSlide;
  var verticalOffset = 0;

if (fade || spec.slideCount === 1) {
    return 0;
  }

if (!vertical) {
    targetLeft = slideIndex * slideWidth * -1 + slideOffset;
  } else {
    targetLeft = slideIndex * slideHeight * -1 + verticalOffset;
  }

if (variableWidth === true) {
    var targetSlideIndex;
    var trackElem = _reactDom2.default.findDOMNode(trackRef);
    targetSlideIndex = slideIndex + getPreClones(spec);
    targetSlide = trackElem && trackElem.childNodes[targetSlideIndex];
    targetLeft = targetSlide ? targetSlide.offsetLeft * -1 : 0;
    if (centerMode === true) {
      targetSlideIndex = infinite ? slideIndex + getPreClones(spec) : slideIndex;
      targetSlide = trackElem && trackElem.children[targetSlideIndex];
      targetLeft = 0;
      for (var slide = 0; slide < targetSlideIndex; slide++) {
        targetLeft -= trackElem && trackElem.children[slide] && trackElem.children[slide].offsetWidth;
      }
      targetLeft -= parseInt(spec.centerPadding);
      targetLeft += targetSlide && (listWidth - targetSlide.offsetWidth) / 2;
    }
  }

return targetLeft;
};

var getPostClones = exports.getPostClones = function getPostClones(spec) {
  if (spec.unslick || !spec.infinite) {
    return 0;
  }
  return spec.slideCount;
};

var slidesOnRight = exports.slidesOnRight = function slidesOnRight(_ref) {
  var slidesToShow = _ref.slidesToShow,
      centerMode = _ref.centerMode,
      rtl = _ref.rtl,
      centerPadding = _ref.centerPadding;

// returns no of slides on the right of active slide
  if (centerMode) {
    var right = (slidesToShow - 1) / 2 + 1;
    if (parseInt(centerPadding) > 0) right += 1;
    if (rtl && slidesToShow % 2 === 0) right += 1;
    return right;
  }
  if (rtl) {
    return 0;
  }
  return slidesToShow - 1;
};

var slidesOnLeft = exports.slidesOnLeft = function slidesOnLeft(_ref2) {
  var slidesToShow = _ref2.slidesToShow,
      centerMode = _ref2.centerMode,
      rtl = _ref2.rtl,
      centerPadding = _ref2.centerPadding;

// returns no of slides on the left of active slide
  if (centerMode) {
    var left = (slidesToShow - 1) / 2 + 1;
    if (parseInt(centerPadding) > 0) left += 1;
    if (!rtl && slidesToShow % 2 === 0) left += 1;
    return left;
  }
  if (rtl) {
    return slidesToShow - 1;
  }
  return 0;
};

var canUseDOM = exports.canUseDOM = function canUseDOM() {
  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
};

/***/ }),
/* 190 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(502),
    isLength = __webpack_require__(142),
    isObjectLike = __webpack_require__(143);

/** `Object#toString` result references. */
var arrayTag = '[object Array]';

/** Used for native method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/* Native method references for those with the same name as other `lodash` methods. */
var nativeIsArray = getNative(Array, 'isArray');

/**
 * Checks if `value` is classified as an `Array` object.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isArray([1, 2, 3]);
 * // => true
 *
 * _.isArray(function() { return arguments; }());
 * // => false
 */
var isArray = nativeIsArray || function(value) {
  return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
};

module.exports = isArray;

/***/ }),
/* 191 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.defaultCellRangeRenderer = exports.Grid = exports.default = undefined;

var _Grid2 = __webpack_require__(1332);

var _Grid3 = _interopRequireDefault(_Grid2);

var _defaultCellRangeRenderer2 = __webpack_require__(509);

var _defaultCellRangeRenderer3 = _interopRequireDefault(_defaultCellRangeRenderer2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _Grid3.default;
exports.Grid = _Grid3.default;
exports.defaultCellRangeRenderer = _defaultCellRangeRenderer3.default;

/***/ }),
/* 192 */
/***/ (function(module, exports, __webpack_require__) {

var disableableMouseListenerNames = {
  onClick: true,
  onDoubleClick: true,
  onMouseDown: true,
  onMouseMove: true,
  onMouseUp: true,

onClickCapture: true,
  onDoubleClickCapture: true,
  onMouseDownCapture: true,
  onMouseMoveCapture: true,
  onMouseUpCapture: true
};

/**
 * Implements a host component that does not receive mouse events
 * when `disabled` is set.
 */
var DisabledInputUtils = {
  getHostProps: function (inst, props) {
    if (!props.disabled) {
      return props;
    }

// Copy the props, except the mouse listeners
    var hostProps = {};
    for (var key in props) {
      if (!disableableMouseListenerNames[key] && props.hasOwnProperty(key)) {
        hostProps[key] = props[key];
      }
    }

return hostProps;
  }
};

module.exports = DisabledInputUtils;

/***/ }),
/* 193 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var invariant = __webpack_require__(19);

/**
 * Injectable ordering of event plugins.
 */
var EventPluginOrder = null;

/**
 * Injectable mapping from names to event plugin modules.
 */
var namesToPlugins = {};

/**
 * Recomputes the plugin list using the injected plugins and plugin ordering.
 *
 * @private
 */
function recomputePluginOrdering() {
  if (!EventPluginOrder) {
    // Wait until an `EventPluginOrder` is injected.
    return;
  }
  for (var pluginName in namesToPlugins) {
    var PluginModule = namesToPlugins[pluginName];
    var pluginIndex = EventPluginOrder.indexOf(pluginName);
    !(pluginIndex > -1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : _prodInvariant('96', pluginName) : void 0;
    if (EventPluginRegistry.plugins[pluginIndex]) {
      continue;
    }
    !PluginModule.extractEvents ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : _prodInvariant('97', pluginName) : void 0;
    EventPluginRegistry.plugins[pluginIndex] = PluginModule;
    var publishedEvents = PluginModule.eventTypes;
    for (var eventName in publishedEvents) {
      !publishEventForPlugin(publishedEvents[eventName], PluginModule, eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : _prodInvariant('98', eventName, pluginName) : void 0;
    }
  }
}

/**
 * Publishes an event so that it can be dispatched by the supplied plugin.
 *
 * @param {object} dispatchConfig Dispatch configuration for the event.
 * @param {object} PluginModule Plugin publishing the event.
 * @return {boolean} True if the event was successfully published.
 * @private
 */
function publishEventForPlugin(dispatchConfig, PluginModule, eventName) {
  !!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : _prodInvariant('99', eventName) : void 0;
  EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;

/**
 * Publishes a registration name that is used to identify dispatched events and
 * can be used with `EventPluginHub.putListener` to register listeners.
 *
 * @param {string} registrationName Registration name to add.
 * @param {object} PluginModule Plugin publishing the event.
 * @private
 */
function publishRegistrationName(registrationName, PluginModule, eventName) {
  !!EventPluginRegistry.registrationNameModules[registrationName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : _prodInvariant('100', registrationName) : void 0;
  EventPluginRegistry.registrationNameModules[registrationName] = PluginModule;
  EventPluginRegistry.registrationNameDependencies[registrationName] = PluginModule.eventTypes[eventName].dependencies;

if (process.env.NODE_ENV !== 'production') {
    var lowerCasedName = registrationName.toLowerCase();
    EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName;

if (registrationName === 'onDoubleClick') {
      EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName;
    }
  }
}

/**
 * Registers plugins so that they can extract and dispatch events.
 *
 * @see {EventPluginHub}
 */
var EventPluginRegistry = {

/**
   * Ordered list of injected plugins.
   */
  plugins: [],

/**
   * Mapping from event name to dispatch config
   */
  eventNameDispatchConfigs: {},

/**
   * Mapping from registration name to plugin module
   */
  registrationNameModules: {},

/**
   * Mapping from registration name to event name
   */
  registrationNameDependencies: {},

/**
   * Mapping from lowercase registration names to the properly cased version,
   * used to warn in the case of missing event handlers. Available
   * only in __DEV__.
   * @type {Object}
   */
  possibleRegistrationNames: process.env.NODE_ENV !== 'production' ? {} : null,

/**
   * Injects an ordering of plugins (by plugin name). This allows the ordering
   * to be decoupled from injection of the actual plugins so that ordering is
   * always deterministic regardless of packaging, on-the-fly injection, etc.
   *
   * @param {array} InjectedEventPluginOrder
   * @internal
   * @see {EventPluginHub.injection.injectEventPluginOrder}
   */
  injectEventPluginOrder: function (InjectedEventPluginOrder) {
    !!EventPluginOrder ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : _prodInvariant('101') : void 0;
    // Clone the ordering so it cannot be dynamically mutated.
    EventPluginOrder = Array.prototype.slice.call(InjectedEventPluginOrder);
    recomputePluginOrdering();
  },

/**
   * Injects plugins to be used by `EventPluginHub`. The plugin names must be
   * in the ordering injected by `injectEventPluginOrder`.
   *
   * Plugins can be injected as part of page initialization or on-the-fly.
   *
   * @param {object} injectedNamesToPlugins Map from names to plugin modules.
   * @internal
   * @see {EventPluginHub.injection.injectEventPluginsByName}
   */
  injectEventPluginsByName: function (injectedNamesToPlugins) {
    var isOrderingDirty = false;
    for (var pluginName in injectedNamesToPlugins) {
      if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
        continue;
      }
      var PluginModule = injectedNamesToPlugins[pluginName];
      if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== PluginModule) {
        !!namesToPlugins[pluginName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : _prodInvariant('102', pluginName) : void 0;
        namesToPlugins[pluginName] = PluginModule;
        isOrderingDirty = true;
      }
    }
    if (isOrderingDirty) {
      recomputePluginOrdering();
    }
  },

/**
   * Looks up the plugin for the supplied event.
   *
   * @param {object} event A synthetic event.
   * @return {?object} The plugin that created the supplied event.
   * @internal
   */
  getPluginModuleForEvent: function (event) {
    var dispatchConfig = event.dispatchConfig;
    if (dispatchConfig.registrationName) {
      return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null;
    }
    for (var phase in dispatchConfig.phasedRegistrationNames) {
      if (!dispatchConfig.phasedRegistrationNames.hasOwnProperty(phase)) {
        continue;
      }
      var PluginModule = EventPluginRegistry.registrationNameModules[dispatchConfig.phasedRegistrationNames[phase]];
      if (PluginModule) {
        return PluginModule;
      }
    }
    return null;
  },

/**
   * Exposed for unit testing.
   * @private
   */
  _resetEventPlugins: function () {
    EventPluginOrder = null;
    for (var pluginName in namesToPlugins) {
      if (namesToPlugins.hasOwnProperty(pluginName)) {
        delete namesToPlugins[pluginName];
      }
    }
    EventPluginRegistry.plugins.length = 0;

var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;
    for (var eventName in eventNameDispatchConfigs) {
      if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {
        delete eventNameDispatchConfigs[eventName];
      }
    }

var registrationNameModules = EventPluginRegistry.registrationNameModules;
    for (var registrationName in registrationNameModules) {
      if (registrationNameModules.hasOwnProperty(registrationName)) {
        delete registrationNameModules[registrationName];
      }
    }

if (process.env.NODE_ENV !== 'production') {
      var possibleRegistrationNames = EventPluginRegistry.possibleRegistrationNames;
      for (var lowerCasedName in possibleRegistrationNames) {
        if (possibleRegistrationNames.hasOwnProperty(lowerCasedName)) {
          delete possibleRegistrationNames[lowerCasedName];
        }
      }
    }
  }

};

module.exports = EventPluginRegistry;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 194 */
/***/ (function(module, exports, __webpack_require__) {

var _assign = __webpack_require__(24);

var EventConstants = __webpack_require__(62);
var EventPluginRegistry = __webpack_require__(193);
var ReactEventEmitterMixin = __webpack_require__(1391);
var ViewportMetrics = __webpack_require__(536);

var getVendorPrefixedEventName = __webpack_require__(1423);
var isEventSupported = __webpack_require__(336);

/**
 * Summary of `ReactBrowserEventEmitter` event handling:
 *
 *  - Top-level delegation is used to trap most native browser events. This
 *    may only occur in the main thread and is the responsibility of
 *    ReactEventListener, which is injected and can therefore support pluggable
 *    event sources. This is the only work that occurs in the main thread.
 *
 *  - We normalize and de-duplicate events to account for browser quirks. This
 *    may be done in the worker thread.
 *
 *  - Forward these native events (with the associated top-level type used to
 *    trap it) to `EventPluginHub`, which in turn will ask plugins if they want
 *    to extract any synthetic events.
 *
 *  - The `EventPluginHub` will then process each event by annotating them with
 *    "dispatches", a sequence of listeners and IDs that care about that event.
 *
 *  - The `EventPluginHub` then dispatches the events.
 *
 * Overview of React and the event system:
 *
 * +------------+    .
 * |    DOM     |    .
 * +------------+    .
 *       |           .
 *       v           .
 * +------------+    .
 * | ReactEvent |    .
 * |  Listener  |    .
 * +------------+    .                         +-----------+
 *       |           .               +--------+|SimpleEvent|
 *       |           .               |         |Plugin     |
 * +-----|------+    .               v         +-----------+
 * |     |      |    .    +--------------+                    +------------+
 * |     +-----------.--->|EventPluginHub|                    |    Event   |
 * |            |    .    |              |     +-----------+  | Propagators|
 * | ReactEvent |    .    |              |     |TapEvent   |  |------------|
 * |  Emitter   |    .    |              |<---+|Plugin     |  |other plugin|
 * |            |    .    |              |     +-----------+  |  utilities |
 * |     +-----------.--->|              |                    +------------+
 * |     |      |    .    +--------------+
 * +-----|------+    .                ^        +-----------+
 *       |           .                |        |Enter/Leave|
 *       +           .                +-------+|Plugin     |
 * +-------------+   .                         +-----------+
 * | application |   .
 * |-------------|   .
 * |             |   .
 * |             |   .
 * +-------------+   .
 *                   .
 *    React Core     .  General Purpose Event Plugin System
 */

var hasEventPageXY;
var alreadyListeningTo = {};
var isMonitoringScrollValue = false;
var reactTopListenersCounter = 0;

// For events like 'submit' which don't consistently bubble (which we trap at a
// lower node than `document`), binding at `document` would cause duplicate
// events so we don't include them here
var topEventMapping = {
  topAbort: 'abort',
  topAnimationEnd: getVendorPrefixedEventName('animationend') || 'animationend',
  topAnimationIteration: getVendorPrefixedEventName('animationiteration') || 'animationiteration',
  topAnimationStart: getVendorPrefixedEventName('animationstart') || 'animationstart',
  topBlur: 'blur',
  topCanPlay: 'canplay',
  topCanPlayThrough: 'canplaythrough',
  topChange: 'change',
  topClick: 'click',
  topCompositionEnd: 'compositionend',
  topCompositionStart: 'compositionstart',
  topCompositionUpdate: 'compositionupdate',
  topContextMenu: 'contextmenu',
  topCopy: 'copy',
  topCut: 'cut',
  topDoubleClick: 'dblclick',
  topDrag: 'drag',
  topDragEnd: 'dragend',
  topDragEnter: 'dragenter',
  topDragExit: 'dragexit',
  topDragLeave: 'dragleave',
  topDragOver: 'dragover',
  topDragStart: 'dragstart',
  topDrop: 'drop',
  topDurationChange: 'durationchange',
  topEmptied: 'emptied',
  topEncrypted: 'encrypted',
  topEnded: 'ended',
  topError: 'error',
  topFocus: 'focus',
  topInput: 'input',
  topKeyDown: 'keydown',
  topKeyPress: 'keypress',
  topKeyUp: 'keyup',
  topLoadedData: 'loadeddata',
  topLoadedMetadata: 'loadedmetadata',
  topLoadStart: 'loadstart',
  topMouseDown: 'mousedown',
  topMouseMove: 'mousemove',
  topMouseOut: 'mouseout',
  topMouseOver: 'mouseover',
  topMouseUp: 'mouseup',
  topPaste: 'paste',
  topPause: 'pause',
  topPlay: 'play',
  topPlaying: 'playing',
  topProgress: 'progress',
  topRateChange: 'ratechange',
  topScroll: 'scroll',
  topSeeked: 'seeked',
  topSeeking: 'seeking',
  topSelectionChange: 'selectionchange',
  topStalled: 'stalled',
  topSuspend: 'suspend',
  topTextInput: 'textInput',
  topTimeUpdate: 'timeupdate',
  topTouchCancel: 'touchcancel',
  topTouchEnd: 'touchend',
  topTouchMove: 'touchmove',
  topTouchStart: 'touchstart',
  topTransitionEnd: getVendorPrefixedEventName('transitionend') || 'transitionend',
  topVolumeChange: 'volumechange',
  topWaiting: 'waiting',
  topWheel: 'wheel'
};

/**
 * To ensure no conflicts with other potential React instances on the page
 */
var topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2);

/**
 * `ReactBrowserEventEmitter` is used to attach top-level event listeners. For
 * example:
 *
 *   EventPluginHub.putListener('myID', 'onClick', myFunction);
 *
 * This would allocate a "registration" of `('onClick', myFunction)` on 'myID'.
 *
 * @internal
 */
var ReactBrowserEventEmitter = _assign({}, ReactEventEmitterMixin, {

/**
   * Injectable event backend
   */
  ReactEventListener: null,

injection: {
    /**
     * @param {object} ReactEventListener
     */
    injectReactEventListener: function (ReactEventListener) {
      ReactEventListener.setHandleTopLevel(ReactBrowserEventEmitter.handleTopLevel);
      ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;
    }
  },

/**
   * Sets whether or not any created callbacks should be enabled.
   *
   * @param {boolean} enabled True if callbacks should be enabled.
   */
  setEnabled: function (enabled) {
    if (ReactBrowserEventEmitter.ReactEventListener) {
      ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);
    }
  },

/**
   * @return {boolean} True if callbacks are enabled.
   */
  isEnabled: function () {
    return !!(ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled());
  },

/**
   * We listen for bubbled touch events on the document object.
   *
   * Firefox v8.01 (and possibly others) exhibited strange behavior when
   * mounting `onmousemove` events at some node that was not the document
   * element. The symptoms were that if your mouse is not moving over something
   * contained within that mount point (for example on the background) the
   * top-level listeners for `onmousemove` won't be called. However, if you
   * register the `mousemove` on the document object, then it will of course
   * catch all `mousemove`s. This along with iOS quirks, justifies restricting
   * top-level listeners to the document object only, at least for these
   * movement types of events and possibly all events.
   *
   * @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
   *
   * Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but
   * they bubble to document.
   *
   * @param {string} registrationName Name of listener (e.g. `onClick`).
   * @param {object} contentDocumentHandle Document which owns the container
   */
  listenTo: function (registrationName, contentDocumentHandle) {
    var mountAt = contentDocumentHandle;
    var isListening = getListeningForDocument(mountAt);
    var dependencies = EventPluginRegistry.registrationNameDependencies[registrationName];

if (isEventSupported('scroll', true)) {
            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topScroll, 'scroll', mountAt);
          } else {
            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topScroll, 'scroll', ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE);
          }
        } else if (dependency === topLevelTypes.topFocus || dependency === topLevelTypes.topBlur) {

if (isEventSupported('focus', true)) {
            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topFocus, 'focus', mountAt);
            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topBlur, 'blur', mountAt);
          } else if (isEventSupported('focusin')) {
            // IE has `focusin` and `focusout` events which bubble.
            // @see http://www.quirksmode.org/blog/archives/2008/04/delegating_the.html
            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topFocus, 'focusin', mountAt);
            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topBlur, 'focusout', mountAt);
          }

// to make sure blur and focus event listeners are only attached once
          isListening[topLevelTypes.topBlur] = true;
          isListening[topLevelTypes.topFocus] = true;
        } else if (topEventMapping.hasOwnProperty(dependency)) {
          ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(dependency, topEventMapping[dependency], mountAt);
        }

isListening[dependency] = true;
      }
    }
  },

trapBubbledEvent: function (topLevelType, handlerBaseName, handle) {
    return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelType, handlerBaseName, handle);
  },

trapCapturedEvent: function (topLevelType, handlerBaseName, handle) {
    return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelType, handlerBaseName, handle);
  },

/**
   * Protect against document.createEvent() returning null
   * Some popup blocker extensions appear to do this:
   * https://github.com/facebook/react/issues/6887
   */
  supportsEventPageXY: function () {
    if (!document.createEvent) {
      return false;
    }
    var ev = document.createEvent('MouseEvent');
    return ev != null && 'pageX' in ev;
  },

/**
   * Listens to window scroll and resize events. We cache scroll values so that
   * application code can access them without triggering reflows.
   *
   * ViewportMetrics is only used by SyntheticMouse/TouchEvent and only when
   * pageX/pageY isn't supported (legacy browsers).
   *
   * NOTE: Scroll events do not bubble.
   *
   * @see http://www.quirksmode.org/dom/events/scroll.html
   */
  ensureScrollValueMonitoring: function () {
    if (hasEventPageXY === undefined) {
      hasEventPageXY = ReactBrowserEventEmitter.supportsEventPageXY();
    }
    if (!hasEventPageXY && !isMonitoringScrollValue) {
      var refresh = ViewportMetrics.refreshScrollValues;
      ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);
      isMonitoringScrollValue = true;
    }
  }

});

module.exports = ReactBrowserEventEmitter;

/***/ }),
/* 195 */
/***/ (function(module, exports, __webpack_require__) {

var keyMirror = __webpack_require__(167);

var ReactPropTypeLocations = keyMirror({
  prop: null,
  context: null,
  childContext: null
});

module.exports = ReactPropTypeLocations;

/***/ }),
/* 196 */
/***/ (function(module, exports, __webpack_require__) {

var SyntheticUIEvent = __webpack_require__(147);
var ViewportMetrics = __webpack_require__(536);

var getEventModifierState = __webpack_require__(333);

/**
 * @interface MouseEvent
 * @see http://www.w3.org/TR/DOM-Level-3-Events/
 */
var MouseEventInterface = {
  screenX: null,
  screenY: null,
  clientX: null,
  clientY: null,
  ctrlKey: null,
  shiftKey: null,
  altKey: null,
  metaKey: null,
  getModifierState: getEventModifierState,
  button: function (event) {
    // Webkit, Firefox, IE9+
    // which:  1 2 3
    // button: 0 1 2 (standard)
    var button = event.button;
    if ('which' in event) {
      return button;
    }
    // IE<9
    // which:  undefined
    // button: 0 0 0
    // button: 1 4 2 (onmouseup)
    return button === 2 ? 2 : button === 4 ? 1 : 0;
  },
  buttons: null,
  relatedTarget: function (event) {
    return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement);
  },
  // "Proprietary" Interface.
  pageX: function (event) {
    return 'pageX' in event ? event.pageX : event.clientX + ViewportMetrics.currentScrollLeft;
  },
  pageY: function (event) {
    return 'pageY' in event ? event.pageY : event.clientY + ViewportMetrics.currentScrollTop;
  }
};

/**
 * @param {object} dispatchConfig Configuration used to dispatch this event.
 * @param {string} dispatchMarker Marker identifying the event target.
 * @param {object} nativeEvent Native browser event.
 * @extends {SyntheticUIEvent}
 */
function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}

SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);

module.exports = SyntheticMouseEvent;

/***/ }),
/* 197 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright 2016-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * Based on the escape-html library, which is used under the MIT License below:
 *
 * Copyright (c) 2012-2013 TJ Holowaychuk
 * Copyright (c) 2015 Andreas Lubbe
 * Copyright (c) 2015 Tiancheng "Timothy" Gu
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * 'Software'), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * @providesModule escapeTextContentForBrowser
 */

// code copied and modified from escape-html
/**
 * Module variables.
 * @private
 */

var matchHtmlRegExp = /["'&<>]/;

/**
 * Escape special characters in the given string of html.
 *
 * @param  {string} string The string to escape for inserting into HTML
 * @return {string}
 * @public
 */

function escapeHtml(string) {
  var str = '' + string;
  var match = matchHtmlRegExp.exec(str);

if (!match) {
    return str;
  }

var escape;
  var html = '';
  var index = 0;
  var lastIndex = 0;

for (index = match.index; index < str.length; index++) {
    switch (str.charCodeAt(index)) {
      case 34:
        // "
        escape = '&quot;';
        break;
      case 38:
        // &
        escape = '&amp;';
        break;
      case 39:
        // '
        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
        break;
      case 60:
        // <
        escape = '&lt;';
        break;
      case 62:
        // >
        escape = '&gt;';
        break;
      default:
        continue;
    }

if (lastIndex !== index) {
      html += str.substring(lastIndex, index);
    }

lastIndex = index + 1;
    html += escape;
  }

return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
}
// end code copied and modified from escape-html

/**
 * Escapes text to prevent scripting attacks.
 *
 * @param {*} text Text value to escape.
 * @return {string} An escaped string.
 */
function escapeTextContentForBrowser(text) {
  if (typeof text === 'boolean' || typeof text === 'number') {
    // this shortcircuit helps perf for types that we know will never have
    // special characters, especially given that this function is used often
    // for numeric dom ids.
    return '' + text;
  }
  return escapeHtml(text);
}

module.exports = escapeTextContentForBrowser;

/***/ }),
/* 198 */
/***/ (function(module, exports, __webpack_require__) {

var ExecutionEnvironment = __webpack_require__(30);
var DOMNamespaces = __webpack_require__(318);

var createMicrosoftUnsafeLocalFunction = __webpack_require__(331);

// SVG temp container for IE lacking innerHTML
var reusableSVGContainer;

/**
 * Set the innerHTML property of a node, ensuring that whitespace is preserved
 * even in IE8.
 *
 * @param {DOMElement} node
 * @param {string} html
 * @internal
 */
var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {
  // IE does not have innerHTML for SVG nodes, so instead we inject the
  // new markup in a temp node and then move the child nodes across into
  // the target node
  if (node.namespaceURI === DOMNamespaces.svg && !('innerHTML' in node)) {
    reusableSVGContainer = reusableSVGContainer || document.createElement('div');
    reusableSVGContainer.innerHTML = '<svg>' + html + '</svg>';
    var svgNode = reusableSVGContainer.firstChild;
    while (svgNode.firstChild) {
      node.appendChild(svgNode.firstChild);
    }
  } else {
    node.innerHTML = html;
  }
});

if (ExecutionEnvironment.canUseDOM) {
  // IE8: When updating a just created node with innerHTML only leading
  // whitespace is removed. When updating an existing node with innerHTML
  // whitespace in root TextNodes is also collapsed.
  // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html

// Feature detection; only IE8 is known to behave improperly like this.
  var testElement = document.createElement('div');
  testElement.innerHTML = ' ';
  if (testElement.innerHTML === '') {
    setInnerHTML = function (node, html) {
      // Magic theory: IE8 supposedly differentiates between added and updated
      // nodes when processing innerHTML, innerHTML on updated nodes suffers
      // from worse whitespace behavior. Re-adding a node like this triggers
      // the initial and more favorable whitespace behavior.
      // TODO: What to do on a detached node?
      if (node.parentNode) {
        node.parentNode.replaceChild(node, node);
      }

// We also implement a workaround for non-visible tags disappearing into
      // thin air on IE8, this only happens if there is no visible text
      // in-front of the non-visible tags. Piggyback on the whitespace fix
      // and simply check if any non-visible tags appear in the source.
      if (WHITESPACE_TEST.test(html) || html[0] === '<' && NONVISIBLE_TEST.test(html)) {
        // Recover leading whitespace by temporarily prepending any character.
        // \uFEFF has the potential advantage of being zero-width/invisible.
        // UglifyJS drops U+FEFF chars when parsing, so use String.fromCharCode
        // in hopes that this is preserved even if "\uFEFF" is transformed to
        // the actual Unicode character (by Babel, for example).
        // https://github.com/mishoo/UglifyJS2/blob/v2.4.20/lib/parse.js#L216
        node.innerHTML = String.fromCharCode(0xFEFF) + html;

// deleteData leaves an empty `TextNode` which offsets the index of all
        // children. Definitely want to avoid this.
        var textNode = node.firstChild;
        if (textNode.data.length === 1) {
          node.removeChild(textNode);
        } else {
          textNode.deleteData(0, 1);
        }
      } else {
        node.innerHTML = html;
      }
    };
  }
  testElement = null;
}

module.exports = setInnerHTML;

/***/ }),
/* 199 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var randomFromSeed = __webpack_require__(1449);

var ORIGINAL = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-';
var alphabet;
var previousSeed;

var shuffled;

function reset() {
    shuffled = false;
}

function setCharacters(_alphabet_) {
    if (!_alphabet_) {
        if (alphabet !== ORIGINAL) {
            alphabet = ORIGINAL;
            reset();
        }
        return;
    }

if (_alphabet_ === alphabet) {
        return;
    }

if (_alphabet_.length !== ORIGINAL.length) {
        throw new Error('Custom alphabet for shortid must be ' + ORIGINAL.length + ' unique characters. You submitted ' + _alphabet_.length + ' characters: ' + _alphabet_);
    }

var unique = _alphabet_.split('').filter(function(item, ind, arr){
       return ind !== arr.lastIndexOf(item);
    });

if (unique.length) {
        throw new Error('Custom alphabet for shortid must be ' + ORIGINAL.length + ' unique characters. These characters were not unique: ' + unique.join(', '));
    }

alphabet = _alphabet_;
    reset();
}

function characters(_alphabet_) {
    setCharacters(_alphabet_);
    return alphabet;
}

function setSeed(seed) {
    randomFromSeed.seed(seed);
    if (previousSeed !== seed) {
        reset();
        previousSeed = seed;
    }
}

function shuffle() {
    if (!alphabet) {
        setCharacters(ORIGINAL);
    }

var sourceArray = alphabet.split('');
    var targetArray = [];
    var r = randomFromSeed.nextValue();
    var characterIndex;

while (sourceArray.length > 0) {
        r = randomFromSeed.nextValue();
        characterIndex = Math.floor(r * sourceArray.length);
        targetArray.push(sourceArray.splice(characterIndex, 1)[0]);
    }
    return targetArray.join('');
}

function getShuffled() {
    if (shuffled) {
        return shuffled;
    }
    shuffled = shuffle();
    return shuffled;
}

/**
 * lookup shuffled letter
 * @param index
 * @returns {string}
 */
function lookup(index) {
    var alphabetShuffled = getShuffled();
    return alphabetShuffled[index];
}

module.exports = {
    characters: characters,
    seed: setSeed,
    lookup: lookup,
    shuffled: getShuffled
};

/***/ }),
/* 200 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
 * vivus - JavaScript library to make drawing animation on SVG
 * @version v0.4.4
 * @link https://github.com/maxwellito/vivus
 * @license MIT
 */

(function () {

'use strict';

/**
 * Pathformer
 * Beta version
 *
 * Take any SVG version 1.1 and transform
 * child elements to 'path' elements
 *
 * This code is purely forked from
 * https://github.com/Waest/SVGPathConverter
 */

/**
 * Class constructor
 *
 * @param {DOM|String} element Dom element of the SVG or id of it
 */
function Pathformer(element) {
  // Test params
  if (typeof element === 'undefined') {
    throw new Error('Pathformer [constructor]: "element" parameter is required');
  }

// Set the element
  if (element.constructor === String) {
    element = document.getElementById(element);
    if (!element) {
      throw new Error('Pathformer [constructor]: "element" parameter is not related to an existing ID');
    }
  }
  if (element instanceof window.SVGElement || 
      element instanceof window.SVGGElement ||
      /^svg$/i.test(element.nodeName)) {
    this.el = element;
  } else {
    throw new Error('Pathformer [constructor]: "element" parameter must be a string or a SVGelement');
  }

// Start
  this.scan(element);
}

/**
 * List of tags which can be transformed
 * to path elements
 *
 * @type {Array}
 */
Pathformer.prototype.TYPES = ['line', 'ellipse', 'circle', 'polygon', 'polyline', 'rect'];

/**
 * List of attribute names which contain
 * data. This array list them to check if
 * they contain bad values, like percentage.
 *
 * @type {Array}
 */
Pathformer.prototype.ATTR_WATCH = ['cx', 'cy', 'points', 'r', 'rx', 'ry', 'x', 'x1', 'x2', 'y', 'y1', 'y2'];

/**
 * Finds the elements compatible for transform
 * and apply the liked method
 *
 * @param  {object} options Object from the constructor
 */
Pathformer.prototype.scan = function (svg) {
  var fn, element, pathData, pathDom,
      elements = svg.querySelectorAll(this.TYPES.join(','));

for (var i = 0; i < elements.length; i++) {
    element = elements[i];
    fn = this[element.tagName.toLowerCase() + 'ToPath'];
    pathData = fn(this.parseAttr(element.attributes));
    pathDom = this.pathMaker(element, pathData);
    element.parentNode.replaceChild(pathDom, element);
  }
};

/**
 * Read `line` element to extract and transform
 * data, to make it ready for a `path` object.
 *
 * @param  {DOMelement} element Line element to transform
 * @return {object}             Data for a `path` element
 */
Pathformer.prototype.lineToPath = function (element) {
  var newElement = {},
      x1 = element.x1 || 0,
      y1 = element.y1 || 0,
      x2 = element.x2 || 0,
      y2 = element.y2 || 0;

newElement.d = 'M' + x1 + ',' + y1 + 'L' + x2 + ',' + y2;
  return newElement;
};

/**
 * Read `rect` element to extract and transform
 * data, to make it ready for a `path` object.
 * The radius-border is not taken in charge yet.
 * (your help is more than welcomed)
 *
 * @param  {DOMelement} element Rect element to transform
 * @return {object}             Data for a `path` element
 */
Pathformer.prototype.rectToPath = function (element) {
  var newElement = {},
      x      = parseFloat(element.x)      || 0,
      y      = parseFloat(element.y)      || 0,
      width  = parseFloat(element.width)  || 0,
      height = parseFloat(element.height) || 0;

if (element.rx || element.ry) {
    var rx = parseInt(element.rx, 10) || -1,
        ry = parseInt(element.ry, 10) || -1;
    rx = Math.min(Math.max(rx < 0 ? ry : rx, 0), width/2);
    ry = Math.min(Math.max(ry < 0 ? rx : ry, 0), height/2);

newElement.d = 'M ' + (x + rx) + ',' + y + ' ' +
                   'L ' + (x + width - rx) + ',' + y + ' ' +
                   'A ' + rx + ',' + ry + ',0,0,1,' + (x + width) + ',' + (y + ry) + ' ' +
                   'L ' + (x + width) + ',' + (y + height - ry) + ' ' +
                   'A ' + rx + ',' + ry + ',0,0,1,' + (x + width - rx) + ',' + (y + height) + ' ' +
                   'L ' + (x + rx) + ',' + (y + height) + ' ' +
                   'A ' + rx + ',' + ry + ',0,0,1,' + x + ',' + (y + height - ry) + ' ' +
                   'L ' + x + ',' + (y + ry) + ' ' +
                   'A ' + rx + ',' + ry + ',0,0,1,' + (x + rx) + ',' + y;
  }
  else {
    newElement.d = 'M' + x + ' ' + y + ' ' +
                   'L' + (x + width) + ' ' + y + ' ' +
                   'L' + (x + width) + ' ' + (y + height) + ' ' +
                   'L' + x + ' ' + (y + height) + ' Z';
  }
  return newElement;
};

/**
 * Read `polyline` element to extract and transform
 * data, to make it ready for a `path` object.
 *
 * @param  {DOMelement} element Polyline element to transform
 * @return {object}             Data for a `path` element
 */
Pathformer.prototype.polylineToPath = function (element) {
  var newElement = {},
      points = element.points.trim().split(' '),
      i, path;

// Reformatting if points are defined without commas
  if (element.points.indexOf(',') === -1) {
    var formattedPoints = [];
    for (i = 0; i < points.length; i+=2) {
      formattedPoints.push(points[i] + ',' + points[i+1]);
    }
    points = formattedPoints;
  }

// Generate the path.d value
  path = 'M' + points[0];
  for(i = 1; i < points.length; i++) {
    if (points[i].indexOf(',') !== -1) {
      path += 'L' + points[i];
    }
  }
  newElement.d = path;
  return newElement;
};

/**
 * Read `polygon` element to extract and transform
 * data, to make it ready for a `path` object.
 * This method rely on polylineToPath, because the
 * logic is similar. The path created is just closed,
 * so it needs an 'Z' at the end.
 *
 * @param  {DOMelement} element Polygon element to transform
 * @return {object}             Data for a `path` element
 */
Pathformer.prototype.polygonToPath = function (element) {
  var newElement = Pathformer.prototype.polylineToPath(element);

newElement.d += 'Z';
  return newElement;
};

/**
 * Read `ellipse` element to extract and transform
 * data, to make it ready for a `path` object.
 *
 * @param  {DOMelement} element ellipse element to transform
 * @return {object}             Data for a `path` element
 */
Pathformer.prototype.ellipseToPath = function (element) {
  var newElement = {},
      rx = parseFloat(element.rx) || 0,
      ry = parseFloat(element.ry) || 0,
      cx = parseFloat(element.cx) || 0,
      cy = parseFloat(element.cy) || 0,
      startX = cx - rx,
      startY = cy,
      endX = parseFloat(cx) + parseFloat(rx),
      endY = cy;

newElement.d = 'M' + startX + ',' + startY +
                 'A' + rx + ',' + ry + ' 0,1,1 ' + endX + ',' + endY +
                 'A' + rx + ',' + ry + ' 0,1,1 ' + startX + ',' + endY;
  return newElement;
};

/**
 * Read `circle` element to extract and transform
 * data, to make it ready for a `path` object.
 *
 * @param  {DOMelement} element Circle element to transform
 * @return {object}             Data for a `path` element
 */
Pathformer.prototype.circleToPath = function (element) {
  var newElement = {},
      r  = parseFloat(element.r)  || 0,
      cx = parseFloat(element.cx) || 0,
      cy = parseFloat(element.cy) || 0,
      startX = cx - r,
      startY = cy,
      endX = parseFloat(cx) + parseFloat(r),
      endY = cy;
      
  newElement.d =  'M' + startX + ',' + startY +
                  'A' + r + ',' + r + ' 0,1,1 ' + endX + ',' + endY +
                  'A' + r + ',' + r + ' 0,1,1 ' + startX + ',' + endY;
  return newElement;
};

/**
 * Create `path` elements form original element
 * and prepared objects
 *
 * @param  {DOMelement} element  Original element to transform
 * @param  {object} pathData     Path data (from `toPath` methods)
 * @return {DOMelement}          Path element
 */
Pathformer.prototype.pathMaker = function (element, pathData) {
  var i, attr, pathTag = document.createElementNS('http://www.w3.org/2000/svg','path');
  for(i = 0; i < element.attributes.length; i++) {
    attr = element.attributes[i];
    if (this.ATTR_WATCH.indexOf(attr.name) === -1) {
      pathTag.setAttribute(attr.name, attr.value);
    }
  }
  for(i in pathData) {
    pathTag.setAttribute(i, pathData[i]);
  }
  return pathTag;
};

/**
 * Parse attributes of a DOM element to
 * get an object of attribute => value
 *
 * @param  {NamedNodeMap} attributes Attributes object from DOM element to parse
 * @return {object}                  Object of attributes
 */
Pathformer.prototype.parseAttr = function (element) {
  var attr, output = {};
  for (var i = 0; i < element.length; i++) {
    attr = element[i];
    // Check if no data attribute contains '%', or the transformation is impossible
    if (this.ATTR_WATCH.indexOf(attr.name) !== -1 && attr.value.indexOf('%') !== -1) {
      throw new Error('Pathformer [parseAttr]: a SVG shape got values in percentage. This cannot be transformed into \'path\' tags. Please use \'viewBox\'.');
    }
    output[attr.name] = attr.value;
  }
  return output;
};

'use strict';

var setupEnv, requestAnimFrame, cancelAnimFrame, parsePositiveInt;

/**
 * Vivus
 * Beta version
 *
 * Take any SVG and make the animation
 * to give give the impression of live drawing
 *
 * This in more than just inspired from codrops
 * At that point, it's a pure fork.
 */

/**
 * Class constructor
 * option structure
 *   type: 'delayed'|'sync'|'oneByOne'|'script' (to know if the items must be drawn synchronously or not, default: delayed)
 *   duration: <int> (in frames)
 *   start: 'inViewport'|'manual'|'autostart' (start automatically the animation, default: inViewport)
 *   delay: <int> (delay between the drawing of first and last path)
 *   dashGap <integer> whitespace extra margin between dashes
 *   pathTimingFunction <function> timing animation function for each path element of the SVG
 *   animTimingFunction <function> timing animation function for the complete SVG
 *   forceRender <boolean> force the browser to re-render all updated path items
 *   selfDestroy <boolean> removes all extra styling on the SVG, and leaves it as original
 *
 * The attribute 'type' is by default on 'delayed'.
 *  - 'delayed'
 *    all paths are draw at the same time but with a
 *    little delay between them before start
 *  - 'sync'
 *    all path are start and finish at the same time
 *  - 'oneByOne'
 *    only one path is draw at the time
 *    the end of the first one will trigger the draw
 *    of the next one
 *
 * All these values can be overwritten individually
 * for each path item in the SVG
 * The value of frames will always take the advantage of
 * the duration value.
 * If you fail somewhere, an error will be thrown.
 * Good luck.
 *
 * @constructor
 * @this {Vivus}
 * @param {DOM|String}   element  Dom element of the SVG or id of it
 * @param {Object}       options  Options about the animation
 * @param {Function}     callback Callback for the end of the animation
 */
function Vivus (element, options, callback) {

setupEnv();

// Setup
  this.isReady = false;
  this.setElement(element, options);
  this.setOptions(options);
  this.setCallback(callback);

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

/**
 * Timing functions
 **************************************
 *
 * Default functions to help developers.
 * It always take a number as parameter (between 0 to 1) then
 * return a number (between 0 and 1)
 */
Vivus.LINEAR          = function (x) {return x;};
Vivus.EASE            = function (x) {return -Math.cos(x * Math.PI) / 2 + 0.5;};
Vivus.EASE_OUT        = function (x) {return 1 - Math.pow(1-x, 3);};
Vivus.EASE_IN         = function (x) {return Math.pow(x, 3);};
Vivus.EASE_OUT_BOUNCE = function (x) {
  var base = -Math.cos(x * (0.5 * Math.PI)) + 1,
    rate = Math.pow(base,1.5),
    rateR = Math.pow(1 - x, 2),
    progress = -Math.abs(Math.cos(rate * (2.5 * Math.PI) )) + 1;
  return (1- rateR) + (progress * rateR);
};

/**
 * Setters
 **************************************
 */

/**
 * Check and set the element in the instance
 * The method will not return anything, but will throw an
 * error if the parameter is invalid
 *
 * @param {DOM|String}   element  SVG Dom element or id of it
 */
Vivus.prototype.setElement = function (element, options) {
  var onLoad, self;

// Basic check
  if (typeof element === 'undefined') {
    throw new Error('Vivus [constructor]: "element" parameter is required');
  }

// Set the element
  if (element.constructor === String) {
    element = document.getElementById(element);
    if (!element) {
      throw new Error('Vivus [constructor]: "element" parameter is not related to an existing ID');
    }
  }
  this.parentEl = element;

// Load the SVG with XMLHttpRequest and extract the SVG
  if (options && options.file) {
    var self = this;
    onLoad = function (e) {
      var domSandbox = document.createElement('div');
      domSandbox.innerHTML = this.responseText;

var svgTag = domSandbox.querySelector('svg');
      if (!svgTag) {
        throw new Error('Vivus [load]: Cannot find the SVG in the loaded file : ' + options.file);
      }

self.el = svgTag
      self.el.setAttribute('width', '100%');
      self.el.setAttribute('height', '100%');
      self.parentEl.appendChild(self.el)
      self.isReady = true;
      self.init();
      self = null;
    }
    
    var oReq = new window.XMLHttpRequest();
    oReq.addEventListener('load', onLoad);
    oReq.open('GET', options.file);
    oReq.send();
    return;
  }

switch (element.constructor) {
  case window.SVGSVGElement:
  case window.SVGElement:
  case window.SVGGElement:
    this.el = element;
    this.isReady = true;
    break;

case window.HTMLObjectElement:
    self = this;
    onLoad = function (e) {
      if (self.isReady) {
        return;
      }
      self.el = element.contentDocument && element.contentDocument.querySelector('svg');
      if (!self.el && e) {
        throw new Error('Vivus [constructor]: object loaded does not contain any SVG');
      }
      else if (self.el) {
        if (element.getAttribute('built-by-vivus')) {
          self.parentEl.insertBefore(self.el, element);
          self.parentEl.removeChild(element);
          self.el.setAttribute('width', '100%');
          self.el.setAttribute('height', '100%');
        }
        self.isReady = true;
        self.init();
        self = null;
      }
    };

if (!onLoad()) {
      element.addEventListener('load', onLoad);
    }
    break;

default:
    throw new Error('Vivus [constructor]: "element" parameter is not valid (or miss the "file" attribute)');
  }
};

/**
 * Set up user option to the instance
 * The method will not return anything, but will throw an
 * error if the parameter is invalid
 *
 * @param  {object} options Object from the constructor
 */
Vivus.prototype.setOptions = function (options) {
  var allowedTypes = ['delayed', 'sync', 'async', 'nsync', 'oneByOne', 'scenario', 'scenario-sync'];
  var allowedStarts =  ['inViewport', 'manual', 'autostart'];

// Basic check
  if (options !== undefined && options.constructor !== Object) {
    throw new Error('Vivus [constructor]: "options" parameter must be an object');
  }
  else {
    options = options || {};
  }

// Set the animation type
  if (options.type && allowedTypes.indexOf(options.type) === -1) {
    throw new Error('Vivus [constructor]: ' + options.type + ' is not an existing animation `type`');
  }
  else {
    this.type = options.type || allowedTypes[0];
  }

// Set the start type
  if (options.start && allowedStarts.indexOf(options.start) === -1) {
    throw new Error('Vivus [constructor]: ' + options.start + ' is not an existing `start` option');
  }
  else {
    this.start = options.start || allowedStarts[0];
  }

this.isIE         = (window.navigator.userAgent.indexOf('MSIE') !== -1 || window.navigator.userAgent.indexOf('Trident/') !== -1 || window.navigator.userAgent.indexOf('Edge/') !== -1 );
  this.duration     = parsePositiveInt(options.duration, 120);
  this.delay        = parsePositiveInt(options.delay, null);
  this.dashGap      = parsePositiveInt(options.dashGap, 1);
  this.forceRender  = options.hasOwnProperty('forceRender') ? !!options.forceRender : this.isIE;
  this.reverseStack = !!options.reverseStack;
  this.selfDestroy  = !!options.selfDestroy;
  this.onReady      = options.onReady;
  this.map          = [];
  this.frameLength  = this.currentFrame = this.delayUnit = this.speed = this.handle = null;

this.ignoreInvisible = options.hasOwnProperty('ignoreInvisible') ? !!options.ignoreInvisible : false;

this.animTimingFunction = options.animTimingFunction || Vivus.LINEAR;
  this.pathTimingFunction = options.pathTimingFunction || Vivus.LINEAR;

if (this.delay >= this.duration) {
    throw new Error('Vivus [constructor]: delay must be shorter than duration');
  }
};

/**
 * Set up callback to the instance
 * The method will not return enything, but will throw an
 * error if the parameter is invalid
 *
 * @param  {Function} callback Callback for the animation end
 */
Vivus.prototype.setCallback = function (callback) {
  // Basic check
  if (!!callback && callback.constructor !== Function) {
    throw new Error('Vivus [constructor]: "callback" parameter must be a function');
  }
  this.callback = callback || function () {};
};

/**
 * Core
 **************************************
 */

/**
 * Map the svg, path by path.
 * The method return nothing, it just fill the
 * `map` array. Each item in this array represent
 * a path element from the SVG, with informations for
 * the animation.
 *
 * ```
 * [
 *   {
 *     el: <DOMobj> the path element
 *     length: <number> length of the path line
 *     startAt: <number> time start of the path animation (in frames)
 *     duration: <number> path animation duration (in frames)
 *   },
 *   ...
 * ]
 * ```
 *
 */
Vivus.prototype.mapping = function () {
  var i, paths, path, pAttrs, pathObj, totalLength, lengthMeter, timePoint;
  timePoint = totalLength = lengthMeter = 0;
  paths = this.el.querySelectorAll('path');

for (i = 0; i < paths.length; i++) {
    path = paths[i];
    if (this.isInvisible(path)) {
      continue;
    }
    pathObj = {
      el: path,
      length: Math.ceil(path.getTotalLength())
    };
    // Test if the path length is correct
    if (isNaN(pathObj.length)) {
      if (window.console && console.warn) {
        console.warn('Vivus [mapping]: cannot retrieve a path element length', path);
      }
      continue;
    }
    this.map.push(pathObj);
    path.style.strokeDasharray  = pathObj.length + ' ' + (pathObj.length + this.dashGap * 2);
    path.style.strokeDashoffset = pathObj.length + this.dashGap;
    pathObj.length += this.dashGap;
    totalLength += pathObj.length;

this.renderPath(i);
  }

totalLength = totalLength === 0 ? 1 : totalLength;
  this.delay = this.delay === null ? this.duration / 3 : this.delay;
  this.delayUnit = this.delay / (paths.length > 1 ? paths.length - 1 : 1);

// Reverse stack if asked
  if (this.reverseStack) {
    this.map.reverse();
  }

for (i = 0; i < this.map.length; i++) {
    pathObj = this.map[i];

switch (this.type) {
    case 'delayed':
      pathObj.startAt = this.delayUnit * i;
      pathObj.duration = this.duration - this.delay;
      break;

case 'oneByOne':
      pathObj.startAt = lengthMeter / totalLength * this.duration;
      pathObj.duration = pathObj.length / totalLength * this.duration;
      break;

case 'sync':
    case 'async':
    case 'nsync':
      pathObj.startAt = 0;
      pathObj.duration = this.duration;
      break;

case 'scenario-sync':
      path = pathObj.el;
      pAttrs = this.parseAttr(path);
      pathObj.startAt = timePoint + (parsePositiveInt(pAttrs['data-delay'], this.delayUnit) || 0);
      pathObj.duration = parsePositiveInt(pAttrs['data-duration'], this.duration);
      timePoint = pAttrs['data-async'] !== undefined ? pathObj.startAt : pathObj.startAt + pathObj.duration;
      this.frameLength = Math.max(this.frameLength, (pathObj.startAt + pathObj.duration));
      break;

case 'scenario':
      path = pathObj.el;
      pAttrs = this.parseAttr(path);
      pathObj.startAt = parsePositiveInt(pAttrs['data-start'], this.delayUnit) || 0;
      pathObj.duration = parsePositiveInt(pAttrs['data-duration'], this.duration);
      this.frameLength = Math.max(this.frameLength, (pathObj.startAt + pathObj.duration));
      break;
    }
    lengthMeter += pathObj.length;
    this.frameLength = this.frameLength || this.duration;
  }
};

/**
 * Interval method to draw the SVG from current
 * position of the animation. It update the value of
 * `currentFrame` and re-trace the SVG.
 *
 * It use this.handle to store the requestAnimationFrame
 * and clear it one the animation is stopped. So this
 * attribute can be used to know if the animation is
 * playing.
 *
 * Once the animation at the end, this method will
 * trigger the Vivus callback.
 *
 */
Vivus.prototype.drawer = function () {
  var self = this;
  this.currentFrame += this.speed;

if (this.currentFrame <= 0) {
    this.stop();
    this.reset();
  } else if (this.currentFrame >= this.frameLength) {
    this.stop();
    this.currentFrame = this.frameLength;
    this.trace();
    if (this.selfDestroy) {
      this.destroy();
    }
  } else {
    this.trace();
    this.handle = requestAnimFrame(function () {
      self.drawer();
    });
    return;
  }

this.callback(this);
  if (this.instanceCallback) {
    this.instanceCallback(this);
    this.instanceCallback = null;
  }
};

/**
 * Draw the SVG at the current instant from the
 * `currentFrame` value. Here is where most of the magic is.
 * The trick is to use the `strokeDashoffset` style property.
 *
 * For optimisation reasons, a new property called `progress`
 * is added in each item of `map`. This one contain the current
 * progress of the path element. Only if the new value is different
 * the new value will be applied to the DOM element. This
 * method save a lot of resources to re-render the SVG. And could
 * be improved if the animation couldn't be played forward.
 *
 */
Vivus.prototype.trace = function () {
  var i, progress, path, currentFrame;
  currentFrame = this.animTimingFunction(this.currentFrame / this.frameLength) * this.frameLength;
  for (i = 0; i < this.map.length; i++) {
    path = this.map[i];
    progress = (currentFrame - path.startAt) / path.duration;
    progress = this.pathTimingFunction(Math.max(0, Math.min(1, progress)));
    if (path.progress !== progress) {
      path.progress = progress;
      path.el.style.strokeDashoffset = Math.floor(path.length * (1 - progress));
      this.renderPath(i);
    }
  }
};

/**
 * Method forcing the browser to re-render a path element
 * from it's index in the map. Depending on the `forceRender`
 * value.
 * The trick is to replace the path element by it's clone.
 * This practice is not recommended because it's asking more
 * ressources, too much DOM manupulation..
 * but it's the only way to let the magic happen on IE.
 * By default, this fallback is only applied on IE.
 *
 * @param  {Number} index Path index
 */
Vivus.prototype.renderPath = function (index) {
  if (this.forceRender && this.map && this.map[index]) {
    var pathObj = this.map[index],
        newPath = pathObj.el.cloneNode(true);
    pathObj.el.parentNode.replaceChild(newPath, pathObj.el);
    pathObj.el = newPath;
  }
};

/**
 * When the SVG object is loaded and ready,
 * this method will continue the initialisation.
 *
 * This this mainly due to the case of passing an
 * object tag in the constructor. It will wait
 * the end of the loading to initialise.
 *
 */
Vivus.prototype.init = function () {
  // Set object variables
  this.frameLength = 0;
  this.currentFrame = 0;
  this.map = [];

// Start
  new Pathformer(this.el);
  this.mapping();
  this.starter();

if (this.onReady) {
    this.onReady(this);
  }
};

/**
 * Trigger to start of the animation.
 * Depending on the `start` value, a different script
 * will be applied.
 *
 * If the `start` value is not valid, an error will be thrown.
 * Even if technically, this is impossible.
 *
 */
Vivus.prototype.starter = function () {
  switch (this.start) {
  case 'manual':
    return;

case 'autostart':
    this.play();
    break;

case 'inViewport':
    var self = this,
    listener = function () {
      if (self.isInViewport(self.parentEl, 1)) {
        self.play();
        window.removeEventListener('scroll', listener);
      }
    };
    window.addEventListener('scroll', listener);
    listener();
    break;
  }
};

/**
 * Controls
 **************************************
 */

/**
 * Get the current status of the animation between
 * three different states: 'start', 'progress', 'end'.
 * @return {string} Instance status
 */
Vivus.prototype.getStatus = function () {
  return this.currentFrame === 0 ? 'start' : this.currentFrame === this.frameLength ? 'end' : 'progress';
};

/**
 * Reset the instance to the initial state : undraw
 * Be careful, it just reset the animation, if you're
 * playing the animation, this won't stop it. But just
 * make it start from start.
 *
 */
Vivus.prototype.reset = function () {
  return this.setFrameProgress(0);
};

/**
 * Set the instance to the final state : drawn
 * Be careful, it just set the animation, if you're
 * playing the animation on rewind, this won't stop it.
 * But just make it start from the end.
 *
 */
Vivus.prototype.finish = function () {
  return this.setFrameProgress(1);
};

/**
 * Set the level of progress of the drawing.
 *
 * @param {number} progress Level of progress to set
 */
Vivus.prototype.setFrameProgress = function (progress) {
  progress = Math.min(1, Math.max(0, progress));
  this.currentFrame = Math.round(this.frameLength * progress);
  this.trace();
  return this;
};

/**
 * Play the animation at the desired speed.
 * Speed must be a valid number (no zero).
 * By default, the speed value is 1.
 * But a negative value is accepted to go forward.
 *
 * And works with float too.
 * But don't forget we are in JavaScript, se be nice
 * with him and give him a 1/2^x value.
 *
 * @param  {number} speed Animation speed [optional]
 */
Vivus.prototype.play = function (speed, callback) {
  this.instanceCallback = null;

if (speed && typeof speed === 'function') {
    this.instanceCallback = speed; // first parameter is actually the callback function
    speed = null;
  }
  else if (speed && typeof speed !== 'number') {
    throw new Error('Vivus [play]: invalid speed');
  }
  // if the first parameter wasn't the callback, check if the seconds was
  if (callback && typeof(callback) === 'function' && !this.instanceCallback) {
    this.instanceCallback = callback;
  }

this.speed = speed || 1;
  if (!this.handle) {
    this.drawer();
  }
  return this;
};

/**
 * Stop the current animation, if on progress.
 * Should not trigger any error.
 *
 */
Vivus.prototype.stop = function () {
  if (this.handle) {
    cancelAnimFrame(this.handle);
    this.handle = null;
  }
  return this;
};

/**
 * Destroy the instance.
 * Remove all bad styling attributes on all
 * path tags
 *
 */
Vivus.prototype.destroy = function () {
  this.stop();
  var i, path;
  for (i = 0; i < this.map.length; i++) {
    path = this.map[i];
    path.el.style.strokeDashoffset = null;
    path.el.style.strokeDasharray = null;
    this.renderPath(i);
  }
};

/**
 * Utils methods
 * include methods from Codrops
 **************************************
 */

/**
 * Method to best guess if a path should added into
 * the animation or not.
 *
 * 1. Use the `data-vivus-ignore` attribute if set
 * 2. Check if the instance must ignore invisible paths
 * 3. Check if the path is visible
 *
 * For now the visibility checking is unstable.
 * It will be used for a beta phase.
 *
 * Other improvments are planned. Like detecting
 * is the path got a stroke or a valid opacity.
 */
Vivus.prototype.isInvisible = function (el) {
  var rect,
    ignoreAttr = el.getAttribute('data-ignore');

if (ignoreAttr !== null) {
    return ignoreAttr !== 'false';
  }

if (this.ignoreInvisible) {
    rect = el.getBoundingClientRect();
    return !rect.width && !rect.height;
  }
  else {
    return false;
  }
};

/**
 * Parse attributes of a DOM element to
 * get an object of {attributeName => attributeValue}
 *
 * @param  {object} element DOM element to parse
 * @return {object}         Object of attributes
 */
Vivus.prototype.parseAttr = function (element) {
  var attr, output = {};
  if (element && element.attributes) {
    for (var i = 0; i < element.attributes.length; i++) {
      attr = element.attributes[i];
      output[attr.name] = attr.value;
    }
  }
  return output;
};

/**
 * Reply if an element is in the page viewport
 *
 * @param  {object} el Element to observe
 * @param  {number} h  Percentage of height
 * @return {boolean}
 */
Vivus.prototype.isInViewport = function (el, h) {
  var scrolled   = this.scrollY(),
    viewed       = scrolled + this.getViewportH(),
    elBCR        = el.getBoundingClientRect(),
    elHeight     = elBCR.height,
    elTop        = scrolled + elBCR.top,
    elBottom     = elTop + elHeight;

// if 0, the element is considered in the viewport as soon as it enters.
  // if 1, the element is considered in the viewport only when it's fully inside
  // value in percentage (1 >= h >= 0)
  h = h || 0;

return (elTop + elHeight * h) <= viewed && (elBottom) >= scrolled;
};

/**
 * Get the viewport height in pixels
 *
 * @return {integer} Viewport height
 */
Vivus.prototype.getViewportH = function () {
  var client = this.docElem.clientHeight,
    inner = window.innerHeight;

if (client < inner) {
    return inner;
  }
  else {
    return client;
  }
};

/**
 * Get the page Y offset
 *
 * @return {integer} Page Y offset
 */
Vivus.prototype.scrollY = function () {
  return window.pageYOffset || this.docElem.scrollTop;
};

setupEnv = function () {

if (Vivus.prototype.docElem) {
    return;
  }

/**
   * Alias for document element
   *
   * @type {DOMelement}
   */
  Vivus.prototype.docElem = window.document.documentElement;

/**
   * Alias for `requestAnimationFrame` or
   * `setTimeout` function for deprecated browsers.
   *
   */
  requestAnimFrame = (function () {
    return (
      window.requestAnimationFrame       ||
      window.webkitRequestAnimationFrame ||
      window.mozRequestAnimationFrame    ||
      window.oRequestAnimationFrame      ||
      window.msRequestAnimationFrame     ||
      function(/* function */ callback){
        return window.setTimeout(callback, 1000 / 60);
      }
    );
  })();

/**
   * Alias for `cancelAnimationFrame` or
   * `cancelTimeout` function for deprecated browsers.
   *
   */
  cancelAnimFrame = (function () {
    return (
      window.cancelAnimationFrame       ||
      window.webkitCancelAnimationFrame ||
      window.mozCancelAnimationFrame    ||
      window.oCancelAnimationFrame      ||
      window.msCancelAnimationFrame     ||
      function(id){
        return window.clearTimeout(id);
      }
    );
  })();
};

/**
 * Parse string to integer.
 * If the number is not positive or null
 * the method will return the default value
 * or 0 if undefined
 *
 * @param {string} value String to parse
 * @param {*} defaultValue Value to return if the result parsed is invalid
 * @return {number}
 *
 */
parsePositiveInt = function (value, defaultValue) {
  var output = parseInt(value, 10);
  return (output >= 0) ? output : defaultValue;
};

if (true) {
    // AMD. Register as an anonymous module.
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
      return Vivus;
    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if (typeof exports === 'object') {
    // Node. Does not work with strict CommonJS, but
    // only CommonJS-like environments that support module.exports,
    // like Node.
    module.exports = Vivus;
  } else {
    // Browser globals
    window.Vivus = Vivus;
  }

}());

/***/ }),
/* 201 */
/***/ (function(module, exports) {

module.exports = function(module) {
	if(!module.webpackPolyfill) {
		module.deprecate = function() {};
		module.paths = [];
		// module.parent = undefined by default
		if(!module.children) module.children = [];
		Object.defineProperty(module, "loaded", {
			enumerable: true,
			get: function() {
				return module.l;
			}
		});
		Object.defineProperty(module, "id", {
			enumerable: true,
			get: function() {
				return module.i;
			}
		});
		module.webpackPolyfill = 1;
	}
	return module;
};

/***/ }),
/* 202 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_warning__ = __webpack_require__(117);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_warning___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_warning__);

/***/ }),
/* 203 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(916);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);

/***/ }),
/* 204 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Checkbox__ = __webpack_require__(345);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__Group__ = __webpack_require__(605);

__WEBPACK_IMPORTED_MODULE_0__Checkbox__["a" /* default */].Group = __WEBPACK_IMPORTED_MODULE_1__Group__["a" /* default */];
/* harmony default export */ __webpack_exports__["default"] = (__WEBPACK_IMPORTED_MODULE_0__Checkbox__["a" /* default */]);

/***/ }),
/* 205 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(917);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);

/***/ }),
/* 206 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ConfigConsumer; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_create_react_context__ = __webpack_require__(840);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_create_react_context___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_create_react_context__);

var ConfigContext = __WEBPACK_IMPORTED_MODULE_1_create_react_context___default()({});
var ConfigProvider = function ConfigProvider(props) {
    var getPopupContainer = props.getPopupContainer,
        children = props.children;

var config = {
        getPopupContainer: getPopupContainer
    };
    return __WEBPACK_IMPORTED_MODULE_0_react__["createElement"](
        ConfigContext.Provider,
        { value: config },
        children
    );
};
var ConfigConsumer = ConfigContext.Consumer;
/* unused harmony default export */ var _unused_webpack_default_export = (ConfigProvider);

/***/ }),
/* 207 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_rc_pagination_es_locale_en_US__ = __webpack_require__(1148);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__date_picker_locale_en_US__ = __webpack_require__(346);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__time_picker_locale_en_US__ = __webpack_require__(352);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__calendar_locale_en_US__ = __webpack_require__(604);

/* harmony default export */ __webpack_exports__["a"] = ({
    locale: 'en',
    Pagination: __WEBPACK_IMPORTED_MODULE_0_rc_pagination_es_locale_en_US__["a" /* default */],
    DatePicker: __WEBPACK_IMPORTED_MODULE_1__date_picker_locale_en_US__["a" /* default */],
    TimePicker: __WEBPACK_IMPORTED_MODULE_2__time_picker_locale_en_US__["a" /* default */],
    Calendar: __WEBPACK_IMPORTED_MODULE_3__calendar_locale_en_US__["a" /* default */],
    // locales for all comoponents
    global: {
        placeholder: 'Please select'
    },
    Table: {
        filterTitle: 'Filter menu',
        filterConfirm: 'OK',
        filterReset: 'Reset',
        emptyText: 'No data',
        selectAll: 'Select current page',
        selectInvert: 'Invert current page',
        sortTitle: 'Sort'
    },
    Modal: {
        okText: 'OK',
        cancelText: 'Cancel',
        justOkText: 'OK'
    },
    Popconfirm: {
        okText: 'OK',
        cancelText: 'Cancel'
    },
    Transfer: {
        titles: ['', ''],
        notFoundContent: 'Not Found',
        searchPlaceholder: 'Search here',
        itemUnit: 'item',
        itemsUnit: 'items'
    },
    Select: {
        notFoundContent: 'Not Found'
    },
    Upload: {
        uploading: 'Uploading...',
        removeFile: 'Remove file',
        uploadError: 'Upload error',
        previewFile: 'Preview file'
    }
});

/***/ }),
/* 208 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_checkbox__ = __webpack_require__(468);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_shallowequal__ = __webpack_require__(115);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_shallowequal___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_10_shallowequal__);

var Radio = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Radio, _React$Component);

function Radio() {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Radio);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Radio.__proto__ || Object.getPrototypeOf(Radio)).apply(this, arguments));

_this.saveCheckbox = function (node) {
            _this.rcCheckbox = node;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Radio, [{
        key: 'shouldComponentUpdate',
        value: function shouldComponentUpdate(nextProps, nextState, nextContext) {
            return !__WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.props, nextProps) || !__WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.state, nextState) || !__WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.context.radioGroup, nextContext.radioGroup);
        }
    }, {
        key: 'focus',
        value: function focus() {
            this.rcCheckbox.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.rcCheckbox.blur();
        }
    }, {
        key: 'render',
        value: function render() {
            var _classNames;

var props = this.props,
                context = this.context;

var prefixCls = props.prefixCls,
                className = props.className,
                children = props.children,
                style = props.style,
                restProps = __rest(props, ["prefixCls", "className", "children", "style"]);

var radioGroup = context.radioGroup;

return Radio;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (Radio);

Radio.defaultProps = {
    prefixCls: 'ant-radio',
    type: 'radio'
};
Radio.contextTypes = {
    radioGroup: __WEBPACK_IMPORTED_MODULE_7_prop_types__["any"]
};

/***/ }),
/* 209 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_switch__ = __webpack_require__(1158);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_switch___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_rc_switch__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_omit_js__ = __webpack_require__(138);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__util_wave__ = __webpack_require__(344);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__icon__ = __webpack_require__(52);

var Switch = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Switch, _React$Component);

function Switch() {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Switch);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Switch.__proto__ || Object.getPrototypeOf(Switch)).apply(this, arguments));

_this.saveSwitch = function (node) {
            _this.rcSwitch = node;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Switch, [{
        key: 'focus',
        value: function focus() {
            this.rcSwitch.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.rcSwitch.blur();
        }
    }, {
        key: 'render',
        value: function render() {
            var _classNames;

var _props = this.props,
                prefixCls = _props.prefixCls,
                size = _props.size,
                loading = _props.loading,
                _props$className = _props.className,
                className = _props$className === undefined ? '' : _props$className,
                disabled = _props.disabled;

return Switch;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["default"] = (Switch);

Switch.defaultProps = {
    prefixCls: 'ant-switch'
};
Switch.propTypes = {
    prefixCls: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    // HACK: https://github.com/ant-design/ant-design/issues/5368
    // size=default and size=large are the same
    size: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOf"](['small', 'default', 'large']),
    className: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"]
};

/***/ }),
/* 210 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(927);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);

/***/ }),
/* 211 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _tooltip = __webpack_require__(58);

var _tooltip2 = _interopRequireDefault(_tooltip);

var _radio = __webpack_require__(622);

var _radio2 = _interopRequireDefault(_radio);

__webpack_require__(59);

__webpack_require__(624);

__webpack_require__(888);

var _EditorHelpers = __webpack_require__(26);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var RadioButton = _radio2.default.Button;
var RadioGroup = _radio2.default.Group;

var BeButtonGroup = function (_React$Component) {
    _inherits(BeButtonGroup, _React$Component);

function BeButtonGroup(props) {
        _classCallCheck(this, BeButtonGroup);

var _this = _possibleConstructorReturn(this, (BeButtonGroup.__proto__ || Object.getPrototypeOf(BeButtonGroup)).call(this, props));

_this.optionsMap = null;
        _this.optionsType = null;
        _this.getRadioButtonList = _this.getRadioButtonList.bind(_this);
        _this.getRadioButton = _this.getRadioButton.bind(_this);
        _this.getRadioButtonProps = _this.getRadioButtonProps.bind(_this);
        _this.handleMultiChange = _this.handleMultiChange.bind(_this);
        _this.handleSingleChange = _this.handleSingleChange.bind(_this);
        _this.isMulti = _this.isMulti.bind(_this);
        return _this;
    }

_createClass(BeButtonGroup, [{
        key: 'validateOptions',
        value: function validateOptions(options) {
            if ((0, _EditorHelpers.hasKeys)(options, ['options']) && (0, _EditorHelpers.validateValues)(options, false, true, true)) {
                return true;
            }
            return false;
        }
    }, {
        key: 'validateValue',
        value: function validateValue(value) {
            return 'string' == typeof value;
        }
    }, {
        key: 'componentWillMount',
        value: function componentWillMount() {
            if (this.validateOptions(this.props.options)) {
                this.optionsMap = this.props.options;
                if ((0, _EditorHelpers.isImmutable)(this.props.options)) {
                    this.optionsType = 'immutable';
                } else if ('[object Object]' == (0, _EditorHelpers.getObjectType)(this.props.options)) {
                    this.optionsType = 'object';
                }
            }
        }
    }, {
        key: 'isMulti',
        value: function isMulti() {
            return 'immutable' == this.optionsType ? this.optionsMap.get('multi') : 'object' == this.optionsType ? this.optionsMap.multi : false;
        }
    }, {
        key: 'getSelectedButtonIndex',
        value: function getSelectedButtonIndex(key) {
            if ('' == this.props.value) {
                return -1;
            } else {
                var valuesArray = this.props.value.split(','),
                    normalizedValuesArray = valuesArray.map(function (val) {
                    return val.trim();
                });
                return normalizedValuesArray.indexOf(key);
            }
        }
    }, {
        key: 'getRadioButtonProps',
        value: function getRadioButtonProps(key) {
            var radioButtonProps = {};
            radioButtonProps.value = key;
            if (this.isMulti()) {
                radioButtonProps.checked = -1 < this.getSelectedButtonIndex(key);
                radioButtonProps.onClick = this.handleMultiChange.bind(null, key);
            }
            return radioButtonProps;
        }
    }, {
        key: 'getRadioButton',
        value: function getRadioButton(value, key) {
            var valueType = (0, _EditorHelpers.isImmutable)(value) ? 'immutable' : '[object Object]' == (0, _EditorHelpers.getObjectType)(value) ? 'object' : 'string',
                radioButtonProps = this.getRadioButtonProps(key);
            if ('immutable' == this.optionsType || 'object' == this.optionsType) {
                if ('string' == valueType) {
                    return React.createElement(
                        RadioButton,
                        radioButtonProps,
                        value
                    );
                } else {
                    var title = 'immutable' == valueType ? value.get('label') : value.label,
                        radioButtonChild = value['immutable' == valueType ? 'has' : 'hasOwnProperty']('icon') ?
                    /*  <Icon type = { 'immutable' == valueType ? value.get( 'icon' ) : value.icon }/> */
                    React.createElement('div', null) : value['immutable' == valueType ? 'has' : 'hasOwnProperty']('svg') ? React.createElement(
                        'svg',
                        { className: 'be-ui-svg' },
                        React.createElement('use', { xlinkHref: 'immutable' == valueType ? value.get('svg') : value.svg })
                    ) : null;
                    return React.createElement(
                        _tooltip2.default,
                        { placement: 'top', title: title },
                        React.createElement(
                            RadioButton,
                            _extends({ style: { width: 'immutable' == this.optionsType ? 100 / this.optionsMap.get('options').size + '%' : 100 / Object.keys(this.optionsMap.options).length + '%' } }, radioButtonProps),
                            radioButtonChild
                        )
                    );
                }
            }
            return null;
        }
    }, {
        key: 'getRadioButtonList',
        value: function getRadioButtonList() {
            var _this2 = this;

if ('immutable' == this.optionsType) {
                return this.optionsMap.get('options').map(function (value, key) {
                    return _this2.getRadioButton(value, key);
                });
            } else if ('object' == this.optionsType) {
                return Object.keys(this.optionsMap.options).map(function (key) {
                    return _this2.getRadioButton(_this2.optionsMap.options[key], key);
                });
            } else {
                return null;
            }
        }
    }, {
        key: 'handleMultiChange',
        value: function handleMultiChange(key) {
            var values = this.props.value,
                valuesArray = '' == values ? [] : values.split(','),
                keyIndex = this.getSelectedButtonIndex(key);
            if (-1 < keyIndex) {
                valuesArray.splice(keyIndex, 1);
                this.props.onChange(valuesArray.join(','));
            } else {
                valuesArray.push(key);
                this.props.onChange(valuesArray.join(','));
            }
        }
    }, {
        key: 'handleSingleChange',
        value: function handleSingleChange(e) {
            var key = e.target.value;
            this.props.onChange(key);
        }
    }, {
        key: 'containsIcons',
        value: function containsIcons(options) {
            if ((0, _EditorHelpers.isImmutable)(options) && options.has('options')) {
                var valSeq = options.get('options').valueSeq();
                if ((0, _EditorHelpers.isImmutable)(valSeq.get(0))) {
                    return true;
                }
            } else if ('[object Object]' == (0, _EditorHelpers.getObjectType)(options) && options.hasOwnProperty('options')) {
                var _valSeq = Object.keys(options.options).map(function (optKey) {
                    return options.options[optKey];
                });
                if ('[object Object]' == (0, _EditorHelpers.getObjectType)(_valSeq[0])) {
                    return true;
                }
            }
            return false;
        }
    }, {
        key: 'render',
        value: function render() {
            var value = this.validateValue(this.props.value) ? this.props.value : '';
            return null != this.optionsMap && React.createElement(
                'div',
                { className: (0, _EditorHelpers.getClassNames)('be-ui-component', 'be-button-group', this.props.className, this.containsIcons(this.optionsMap) ? 'be-button-group-with-icons' : '') },
                !this.isMulti() ? React.createElement(
                    RadioGroup,
                    { value: value, onChange: this.handleSingleChange },
                    this.getRadioButtonList()
                ) : this.getRadioButtonList()
            );
        }
    }]);

return BeButtonGroup;
}(React.Component);

exports.default = BeButtonGroup;

/** options syntax **/
/*
options : {
    isMulti : true,
    buttons : {
        desktop  : {
            'icon' : 'desktop',
            'label' : 'Desktop'
        },
        laptop : {
            'svg' : 'use-url',
            'label' : 'Laptop'
        }
    }
}
options => array (
    'isMulti' => true,
    'buttons' => array (
        'left' => "Left",
        'right' => 'Right'
    ),
    'button' => array (
        'left' => array (
            'icon' => 'left',
            'tooltip' => 'Left'
        )
    )
)
*/
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 212 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var isEmpty = __webpack_require__(5),
    GradientColorPicker = __webpack_require__(644),
    RenderToBody = __webpack_require__(125),
    findDOMNode = ReactDOM.findDOMNode,
    computeColorforCSS = __webpack_require__(94),
    typewatch = __webpack_require__(122);

var GradientColor = React.createClass({
	displayName: 'GradientColor',

validateColor: function validateColor(color) {

getInputProps: function getInputProps(props) {
		var newColor = {};
		propAsObject = {};
		if (typeof props.value == 'string' && this.validateColor(props.value)) {
			newColor = {
				active: 'solid',
				solid: {
					color: props.value
				}
			};
		} else if (Immutable.Map.isMap(props.value)) {
			var propAsObject = props.value.toJS();
			if (props.value.has('active')) {
				if (props.value.has('id')) {
					newColor = {
						active: propAsObject.active,
						id: propAsObject.id
					};
					newColor[propAsObject.active] = propAsObject[propAsObject.active];
				} else {
					newColor = {
						active: propAsObject.active,
						solid: {
							color: propAsObject.solid.color
						},
						gradient: {
							color: propAsObject.gradient.color
						}
					};
				}
			} else {
				if (props.value.has('id')) {
					if (typeof propAsObject.color !== 'string') {
						newColor = {
							active: 'gradient',
							gradient: {
								color: propAsObject.color
							},
							id: props.value.get('id')
						};
					} else {
						newColor = {
							active: 'solid',
							solid: {
								color: propAsObject.color
							},
							id: props.value.get('id')
						};
					}
				} else {
					newColor = {
						active: 'gradient',
						gradient: {
							color: props.value.toJS()
						}
					};
				}
			}
		}
		return newColor;
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
		var newColor = {};
		newColor = this.getInputProps(nextProps);
		this.setState({
			color: newColor,
			colorStyle: computeColorforCSS(newColor).color
		});
	},

getInitialState: function getInitialState() {
		var value = {};
		value = this.getInputProps(this.props);
		return {
			displayColorPicker: false,
			top: null,
			color: value,
			colorStyle: computeColorforCSS(value).color
		};
	},

_handleClose: function _handleClose() {

this.setState({
			displayColorPicker: false
		});
	},

_getTop: function _getTop(panel) {

_calculateTop: function _calculateTop(panel) {

if (this.state.displayColorPicker) {
			var curTop = this._getTop(panel);
			this.setState({
				top: curTop
			});
		}
	},

_handleToggle: function _handleToggle() {

var currentState = this.state.displayColorPicker;
		this.setState({
			displayColorPicker: !currentState
		});
	},

handleChange: function handleChange(colorPickerData) {

currentStateRenderer: function currentStateRenderer(isVisible) {

if (Immutable.Map.isMap(this.props.options)) {
			var gradientOption = this.props.options.get('gradient');
		}

var leftpanelWrapper = document.getElementById('be-pb-leftpanel-inner-wrap'),
		    leftpanelHeight = '100%',
		    quickChange = !this.props.isAjax,
		    enableSwatch = false,
		    enablePalette = false,
		    enableGradient = this.state.color.active === 'gradient' ? true : gradientOption,
		    //Enable Gradient when color set from palette is of type Gradient. Although Gradient may be set to false in Module Options.
		colorHub = '';

if (null != leftpanelWrapper) {
			leftpanelHeight = leftpanelWrapper.scrollHeight;
		}
		if (window.colorhub) {
			//Check of Color HUB Plugin is active
			enableSwatch = true;
			enablePalette = true;
			colorHub = window.colorhub;
		}
		if (isVisible) {
			return React.createElement(
				RenderToBody,
				null,
				React.createElement(
					'div',
					{ className: 'be-pb-pop-over' },
					React.createElement('div', { style: { position: 'absolute', top: '0', bottom: '0', right: '0', left: '0', zIndex: '100', height: leftpanelHeight }, onClick: this._handleClose }),
					React.createElement(
						'div',
						{ style: { zIndex: '10000', position: 'absolute', left: '20px', top: this.state.top } },
						React.createElement(GradientColorPicker, {
							calculateTop: this._calculateTop,
							enableGradient: enableGradient,
							enableSwatch: enableSwatch,
							enablePalette: enablePalette,
							colorHub: colorHub,
							color: this.state.color,
							quickChange: quickChange,
							onChange: this.handleChange
						})
					)
				)
			);
		} else {
			return null;
		}
	},

render: function render() {
		var colorPickerVisibilty = this.state.displayColorPicker,
		    swatchStyle = {
			backgroundImage: 'url(' + tatsuConfig.plugin_url + '/img/nobg.png)',
			backgroundRepeat: 'repeat',
			backgroundPosition: '0% 0%',
			position: 'relative'
		};
		var backgroundColor = '';

if (!isEmpty(this.state.color)) {
			backgroundColor = this.state.colorStyle;
		}
		return React.createElement(
			'div',
			{ className: 'tatsu-colorpicker-wrap' },
			React.createElement(
				'div',
				{ className: 'tatsu-colorpicker-swatch', style: swatchStyle, onClick: this._handleToggle },
				React.createElement('div', { className: 'tatsu-colorpicker-swatch-inner', style: { background: backgroundColor } })
			),
			this.currentStateRenderer(colorPickerVisibilty),
			!this.props.hideClearBtn && React.createElement(
				'div',
				{ className: 'tatsu-colorpicker-clear-btn' },
				React.createElement(
					'svg',
					{ onClick: this.props.onChange.bind(null, '', 1), className: 'tatsu-svg-icon', viewBox: '0 0 20 20' },
					React.createElement('path', { fill: 'red', d: 'M15.898,4.045c-0.271-0.272-0.713-0.272-0.986,0l-4.71,4.711L5.493,4.045c-0.272-0.272-0.714-0.272-0.986,0s-0.272,0.714,0,0.986l4.709,4.711l-4.71,4.711c-0.272,0.271-0.272,0.713,0,0.986c0.136,0.136,0.314,0.203,0.492,0.203c0.179,0,0.357-0.067,0.493-0.203l4.711-4.711l4.71,4.711c0.137,0.136,0.314,0.203,0.494,0.203c0.178,0,0.355-0.067,0.492-0.203c0.273-0.273,0.273-0.715,0-0.986l-4.711-4.711l4.711-4.711C16.172,4.759,16.172,4.317,15.898,4.045z' })
				)
			)
		);
	}
});

module.exports = GradientColor;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 213 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _index = __webpack_require__(150);

var _index2 = _interopRequireDefault(_index);

var _EditorHelpers = __webpack_require__(26);

var _getCSSValueAndUnit = __webpack_require__(237);

var _getCSSValueAndUnit2 = _interopRequireDefault(_getCSSValueAndUnit);

__webpack_require__(892);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var BeNumberInputGroup = function (_React$Component) {
    _inherits(BeNumberInputGroup, _React$Component);

function BeNumberInputGroup(props) {
        _classCallCheck(this, BeNumberInputGroup);

var _this = _possibleConstructorReturn(this, (BeNumberInputGroup.__proto__ || Object.getPrototypeOf(BeNumberInputGroup)).call(this, props));

_this.options = null;
        _this.optionsType = null;
        _this.state = {
            value: ''
        };
        return _this;
    }

_createClass(BeNumberInputGroup, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            var parsedValue = void 0;
            this.processOptions(this.props.options);
            parsedValue = this.parseValue(this.props.value);
            this.setState({
                value: parsedValue
            });
        }
    }, {
        key: 'processOptions',
        value: function processOptions(options) {
            if ((0, _EditorHelpers.isValidDataStructure)(options) && (0, _EditorHelpers.hasKeys)(options, ['unit']) && (0, _EditorHelpers.validateValues)(options, true, true, true)) {
                this.options = options;
                if ((0, _EditorHelpers.isImmutable)(options)) {
                    this.optionsType = 'immutable';
                } else if ('[object Object]' == (0, _EditorHelpers.getObjectType)(options)) {
                    this.optionsType = 'object';
                }
            }
        }
    }, {
        key: 'getOptionDefault',
        value: function getOptionDefault(option) {
            switch (option) {
                case 'min':
                    return 0;
                case 'max':
                    return 100;
                case 'step':
                    return 1;
                case 'unit':
                    return [];
                default:
                    return -1;
            }
        }
    }, {
        key: 'getOptionVal',
        value: function getOptionVal(option) {
            if ('object' == this.optionsType) {
                var val = this.options[option];
                if (this.options.hasOwnProperty(option)) {
                    if ('[object Array]' == (0, _EditorHelpers.getObjectType)(val)) {
                        return val;
                    } else if ('string' == (0, _EditorHelpers.getObjectType)(val)) {
                        return val;
                    } else {
                        return this.getOptionDefault(option);
                    }
                } else {
                    if ('min' === option) {
                        return -Infinity;
                    } else if ('max' === option) {
                        return Infinity;
                    } else {
                        return null;
                    }
                }
            } else if ('immutable' == this.optionsType) {
                if (this.options.has(option)) {
                    var _val = this.options.get(option);
                    if ('unit' == option) {
                        if ('[object Object]' == (0, _EditorHelpers.getObjectType)(_val)) {
                            return _val.toArray();
                        } else if ('string' == (0, _EditorHelpers.getObjectType)(_val)) {
                            return _val;
                        } else {
                            return this.getOptionDefault(option);
                        }
                    } else if (!isNaN(_val)) {
                        return _val;
                    } else {
                        return this.getOptionDefault(option);
                    }
                } else {
                    if ('min' === option) {
                        return -Infinity;
                    } else if ('max' === option) {
                        return Infinity;
                    } else {
                        return null;
                    }
                }
            }
            return null;
        }
    }, {
        key: 'getDefaultValueBasedOnLength',
        value: function getDefaultValueBasedOnLength(length) {
            var val = '';
            while (length--) {
                val += "0px" + (0 == length ? "" : " ");
            }
            return val;
        }
    }, {
        key: 'parseValue',
        value: function parseValue(value) {
            var _this2 = this;

if (null != this.optionsType) {
                var labelCount = 'immutable' == this.optionsType ? this.options.get('labels').size : this.options.labels.length,
                    labels = 'immutable' == this.optionsType ? this.options.get('labels') : this.options.labels;
                if ('string' == typeof value) {
                    var valArray = '' !== value ? value.split(" ") : [],
                        min = this.getOptionVal('min'),
                        max = this.getOptionVal('max'),
                        unit = typeof this.getOptionVal('unit') === 'string' ? [this.getOptionVal('unit')] : this.getOptionVal('unit');
                    valArray = labels.map(function (label, index) {
                        var val = valArray[index],
                            valueAndUnit = void 0;
                        if ('' === value) {
                            return '';
                        }
                        if (val === '' && !_this2.props.link) {
                            return '0';
                        }
                        val = val || '0';
                        valueAndUnit = (0, _getCSSValueAndUnit2.default)(val.trim());
                        if (' ' === valueAndUnit) {
                            valueAndUnit = { value: 0, unit: val.trim() };
                        }
                        if (-1 == unit.indexOf(valueAndUnit.unit)) {
                            valueAndUnit.unit = unit[0];
                        }
                        if (isNaN(valueAndUnit.value)) {
                            return min + valueAndUnit.unit;
                        } else if (valueAndUnit.value < min) {
                            return min + valueAndUnit.unit;
                        } else if (valueAndUnit.value > max) {
                            return max + valueAndUnit.unit;
                        } else {
                            return valueAndUnit.value + valueAndUnit.unit;
                        }
                    });
                    return valArray.join(' ');
                }
                return this.getDefaultValueBasedOnLength(labelCount);
            } else {
                return '';
            }
        }
    }, {
        key: 'changeHandler',
        value: function changeHandler(index, val) {
            var currentValue = this.state.value,
                currentValueArray = currentValue.toString().split(' '),
                updatedValue = '';
            if ('' !== val) {
                if (this.props.link) {
                    currentValueArray = currentValueArray.map(function (value) {
                        return val;
                    });
                } else {
                    currentValueArray = currentValueArray.map(function (val, valIndex) {
                        return valIndex !== index && '' === val ? 0 : val;
                    });
                    if (null != currentValueArray[index]) {
                        currentValueArray[index] = val;
                    }
                }
                updatedValue = currentValueArray.join(' ');
            }
            //comment this
            // this.setState({
            //     value : updatedValue
            // });
            this.props.onChange(updatedValue);
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            var parsedValue = void 0;
            this.processOptions(nextProps.options);
            parsedValue = this.parseValue(nextProps.value);
            this.setState({
                value: parsedValue
            });
        }
    }, {
        key: 'render',
        value: function render() {
            var _this3 = this;

//'immutable' == this.optionsType ? labels.get( index ) : labels[ index ]
                            //'immutable' == this.optionsType ? labels.get('index') : labels[index]
                            label
                        ),
                        React.createElement(_index2.default, {
                            value: values[index],
                            onChange: _this3.changeHandler.bind(_this3, index),
                            options: _this3.options,
                            isAjax: _this3.props.isAjax,
                            resetPossible: '' === values[index] || _this3.props.link
                        })
                    );
                })
            ) : null;
        }
    }]);

return BeNumberInputGroup;
}(React.Component);

exports.default = BeNumberInputGroup;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 214 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _birdsEyeViewBlockWrapper = __webpack_require__(671);

var _birdsEyeViewBlockWrapper2 = _interopRequireDefault(_birdsEyeViewBlockWrapper);

var _addModules = __webpack_require__(669);

var _addModules2 = _interopRequireDefault(_addModules);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var BirdsEyeViewList = function (_React$Component) {
    _inherits(BirdsEyeViewList, _React$Component);

function BirdsEyeViewList() {
        _classCallCheck(this, BirdsEyeViewList);

return _possibleConstructorReturn(this, (BirdsEyeViewList.__proto__ || Object.getPrototypeOf(BirdsEyeViewList)).apply(this, arguments));
    }

_createClass(BirdsEyeViewList, [{
        key: 'render',
        value: function render() {
            var _this2 = this;

var path = this.props.path || Immutable.List(),
                moduleChildren = this.props.moduleChildren,
                moduleOptions = this.props.moduleOptions,
                targetElement = this.props.module,
                builderMode = this.props.builderMode,
                showAddModuleBtn = false,
                modulesWithFixedChildren = ['tatsu_hamburger_menu', 'tatsu_row', 'tatsu_header_row', 'tatsu_inner_row'];

if (!this.props.isLayoutPanel) {
                if (this.props.builderMode === 'header_builder') {
                    if (path.size !== 1 && modulesWithFixedChildren.indexOf(targetElement.get('name')) === -1) {
                        showAddModuleBtn = true;
                    }
                } else {
                    if (modulesWithFixedChildren.indexOf(targetElement.get('name')) === -1) {
                        showAddModuleBtn = true;
                    }
                }
            } else {
                if (modulesWithFixedChildren.indexOf(targetElement.get('name')) === -1) {
                    showAddModuleBtn = true;
                }
            }

var childModuleName = 'home' == targetElement.get('name') ? builderMode === 'header_builder' ? 'tatsu_header_row' : 'tatsu_section' : moduleOptions.getIn([targetElement.get('name'), 'child_module']),
                childModuleLabel = 'module' == childModuleName ? 'Module' : moduleOptions.getIn([childModuleName, 'title']);

var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';

return Immutable.List.isList(moduleChildren) ? React.createElement(
                'div',
                { className: 'be-birdseye-view-list', style: { padding: this.props.addPadding ? '20px 20px 300px' : null, marginTop: this.props.isLayoutPanel ? 20 : 0 } },
                [moduleChildren.map(function (child, index) {
                    return React.createElement(_birdsEyeViewBlockWrapper2.default, { key: child.get('id'), openSelectedPath: _this2.props.openSelectedPath || false, moduleOptions: moduleOptions, path: path.push(index), module: child, selectionState: _this2.props.selectionState, isLayoutPanel: _this2.props.isLayoutPanel, builderMode: builderMode, targetDisplay: _this2.props.targetDisplay, parentModule: targetElement });
                }), showAddModuleBtn && childModuleLabel ? React.createElement(_addModules2.default, { isLayoutPanel: this.props.isLayoutPanel, customStyles: path.size !== 0 ? { marginLeft: this.props.isLayoutPanel ? 0 : 15 } : { background: primaryColor, color: '#fff' }, path: path, name: childModuleName, label: childModuleLabel }) : '']
            ) : null;
        }
    }]);

return BirdsEyeViewList;
}(React.Component);

exports.default = BirdsEyeViewList;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 215 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, $, Immutable) {

var listChecker = __webpack_require__(16).listChecker,
    columnLayout = __webpack_require__(2).columnLayout,
    store = __webpack_require__(11),
    layoutArray = __webpack_require__(683).layoutArray;
var ColumnSwitch = React.createClass({
    displayName: 'ColumnSwitch',

propTypes: {
        targetLayout: React.PropTypes.string.isRequired,
        path: listChecker
    },
    splitSelect: function splitSelect(path, event) {
        //handles the switching between column layouts!

var selectedSplit = $(event.currentTarget),
            layout = selectedSplit.attr('data-layout'),
            builderMode = this.props.builderMode;
        if (layout === this.props.targetLayout) {
            return;
        }
        store.dispatch(columnLayout(layout, path));
    },
    shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
        result = !(this.props.targetLayout === nextProps.targetLayout && Immutable.is(this.props.path, nextProps.path));
        return result;
    },
    render: function render() {
        var targetLayout = this.props.targetLayout,
            path = this.props.path;

return React.createElement(
            'div',
            { className: 'be-pb-module-switch', ref: 'layoutRef' },
            React.createElement(
                'ul',
                { id: 'be-pb-columns-layout' },
                layoutArray.map(function (layout) {
                    var fractionArray = layout.split("+"),
                        //Spliting the layout into different fractions!!
                    isActive = '',
                        fractionArrayData = fractionArray.map(function (fraction) {
                        var fragmentArray = fraction.split("/"),
                            //Obtain the numerator and denominator of the fractions!!
                        className = "be-pb" + "-" + fragmentArray[0] + "-" + (fragmentArray[1] || 'layout'); //Note that fragment[0] is the numerator and fragment[1] is the denominator!! And I have added || layout so that when the layout is "custom", the numerator will be 'custom' and the denominator will be 'layout'!!
                        return React.createElement('div', { className: className });
                    });
                    if (layout === targetLayout) {
                        //If the current layout in the model ( Row /InnerRow ) is similar to this layout in the layoutArray, add the class active!!!
                        isActive = 'active';
                    }
                    return React.createElement(
                        'li',
                        { onClick: this.splitSelect.bind(null, path), className: "be-pb-column-wrapper " + isActive, 'data-layout': layout },
                        fractionArrayData
                    );
                }.bind(this))
            )
        );
    }
});
module.exports = ColumnSwitch;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(3)))

/***/ }),
/* 216 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var React = __webpack_require__(0),
    customDebounce = __webpack_require__(122),
    getBookmark = __webpack_require__(32).getBookmark,
    getNeededStyleValue = __webpack_require__(32).getNeededStyleValue,
    moveToBookmark = __webpack_require__(32).moveToBookmark,
    colorRegex = __webpack_require__(684).generalColorRegex,
    SimpleColorPicker = __webpack_require__(1270);
var ColorPicker = React.createClass({
    displayName: 'ColorPicker',

currentBookMark: null,

_getCurrentColor: function _getCurrentColor() {

return getNeededStyleValue(this.props.activeEditorId, 'color');
    },

_handleInputMouseDown: function _handleInputMouseDown(event) {

event.stopPropagation();
        if (!this.props.isOverriden) {
            this.currentBookMark = getBookmark(this.props.activeEditorId);
            this.props.useOverride(true);
        }
    },

_handleMouseDown: function _handleMouseDown(event) {

event.preventDefault();
        if (this.currentBookMark) {
            var curBookmark = this.currentBookMark;
            this.currentBookMark = null;
            moveToBookmark(curBookmark, this.props.activeEditorId);
            if (this.props.isOverriden) {
                this.props.useOverride(false);
            }
        }
    },

_applyColor: function _applyColor(color, event) {

if (this.currentBookMark) {
            var curBookMark = this.currentBookMark;
            this.currentBookMark = null;
            moveToBookmark(curBookMark, this.props.activeEditorId);
            this.props.useOverride(false);
        }
        var colorString = color;
        this.props.applyColor(colorString);
    },

_checkIfValidColor: function _checkIfValidColor(inputColor) {

var bookmarkValue;
        if (colorRegex.test(inputColor) || '' == inputColor) {
            bookmarkValue = this.currentBookMark;
            this.currentBookMark = null;
            moveToBookmark(bookmarkValue, this.props.activeEditorId);
            this.props.useOverride(false);
            this.props.applyColor(inputColor);
        }
    },

_handleKeyUp: function _handleKeyUp(event) {
        customDebounce(this._checkIfValidColor, 500, event.target.value);
    },

_handleBlur: function _handleBlur(event) {

setTimeout(function () {
            if (this.currentBookMark) {
                this.currentBookMark = null;
                this.props.resetState();
            }
        }.bind(this), 0);
    },

_preventDefaultAndStopPropagation: function _preventDefaultAndStopPropagation(event) {

event.preventDefault();
        event.stopPropagation();
    },

_preventDefault: function _preventDefault(event) {

event.preventDefault();
    },

_preventPropagation: function _preventPropagation(event) {

event.stopPropagation();
    },

componentDidUpdate: function componentDidUpdate() {

var currentColorInInput = this.refs.colorInput.value,
            currentActualColor = this._getCurrentColor();
        if (currentActualColor != currentColorInInput) {
            this.refs.colorInput.value = currentActualColor;
        }
    },

_handleClose: function _handleClose(event) {

event.preventDefault();
        event.stopPropagation();
        this.props.toggleTool('colorPicker');
    },

render: function render() {

var currentColor = this._getCurrentColor() || 'rgb(32,203,212)';
        return React.createElement(
            'div',
            { className: 'tatsu-inline-color-controller' },
            React.createElement(
                'div',
                { className: 'tatsu-inline-color-tools-wrapper' },
                React.createElement('input', { onBlur: this._handleBlur, onClick: this._preventPropagation, onMouseDown: this._handleInputMouseDown, type: 'text', id: 'tatsu-inline-color-input', onChange: this._handleKeyUp, defaultValue: this._getCurrentColor(), ref: 'colorInput' }),
                React.createElement(
                    'div',
                    { className: 'tatsu-inline-button', onMouseDown: this._handleMouseDown, onMouseUp: this._preventDefault, onClick: this._handleClose, style: { height: '20px', lineHeight: '0px', minWidth: '20px', cursor: 'pointer', position: 'absolute', right: 5, top: 5 } },
                    React.createElement(
                        'svg',
                        { className: 'tatsu-svg-icon colorhub', fill: '#fff', viewBox: '0 0 20 20' },
                        React.createElement('path', { d: 'M15.898,4.045c-0.271-0.272-0.713-0.272-0.986,0l-4.71,4.711L5.493,4.045c-0.272-0.272-0.714-0.272-0.986,0s-0.272,0.714,0,0.986l4.709,4.711l-4.71,4.711c-0.272,0.271-0.272,0.713,0,0.986c0.136,0.136,0.314,0.203,0.492,0.203c0.179,0,0.357-0.067,0.493-0.203l4.711-4.711l4.71,4.711c0.137,0.136,0.314,0.203,0.494,0.203c0.178,0,0.355-0.067,0.492-0.203c0.273-0.273,0.273-0.715,0-0.986l-4.711-4.711l4.711-4.711C16.172,4.759,16.172,4.317,15.898,4.045z' })
                    )
                )
            ),
            React.createElement(
                'div',
                { className: 'tatsu-inline-colorpicker-wrapper', onMouseDown: this._preventDefaultAndStopPropagation },
                React.createElement(SimpleColorPicker, { color: currentColor, onChange: this._applyColor, opacitySlider: true })
            )
        );
    }

});
module.exports = ColorPicker;

/***/ }),
/* 217 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, React, jQuery) {

var setSelection = __webpack_require__(2).setSelection,
    openDrawer = __webpack_require__(2).openDrawer,
    openContextMenu = __webpack_require__(2).openContextMenu,
    routeHandler = __webpack_require__(99),
    fitVideoToContainer = __webpack_require__(236),
    cssAnimateHelper = __webpack_require__(120),
    CssNewAnimate = __webpack_require__(124),
    triggerJs = __webpack_require__(126),
    Module = __webpack_require__(152),
    getAttFromDisplay = __webpack_require__(123),
    setDragPlaceholder = __webpack_require__(2).setDragPlaceholder,
    resetDragPlaceholder = __webpack_require__(2).resetDragPlaceholder,
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    DropTarget = __webpack_require__(37).DropTarget,
    getAttsBasedOnTargetDisplay = __webpack_require__(53),
    isEqual = __webpack_require__(86),
    getModuleStyle = __webpack_require__(96),
    editAtt = __webpack_require__(2).editAtt,
    getConcatenatedCSS = __webpack_require__(67),
    findDOMNode = __webpack_require__(7).findDOMNode,
    flow = __webpack_require__(60),
    store = __webpack_require__(11),
    isEmpty = __webpack_require__(5),
    dndScope = __webpack_require__(79).moduleListDnDConstant;
var dropSpec = {
  hover: function hover(props, monitor, component) {

drop: function drop(props, monitor) {

};

function collect(connect, monitor) {

return {
    connectDropTarget: connect.dropTarget(),
    canDrop: monitor.canDrop(),
    isOver: monitor.isOver()
  };
}

var Column = React.createClass({
  displayName: 'Column',

setBorder: null,
  animateObj: null,
  triggerJs: false,
  prevCurPos: -1,
  rowWidth: false,
  initialCssAnimationTriggered: false,
  triggerAnimation: false,
  triggerParallax: false,
  triggerTilt: false,
  triggerSticky: false,
  propTypes: {
    path: listChecker,
    column: mapChecker,
    connectDropTarget: React.PropTypes.func.isRequired,
    targetDisplay: React.PropTypes.string,
    pathFromSelectionState: listChecker,
    dropEffect: React.PropTypes.string,
    moduleOptions: mapChecker,
    parent: mapChecker,
    isOver: React.PropTypes.bool,
    canDrop: React.PropTypes.bool
  },
  getInitialState: function getInitialState() {
    return {
      hovered: false,
      widthDragger: Immutable.Map({
        position: false,
        active: false
      })
    };
  },

componentWillMount: function componentWillMount() {

this.animateObj = new CssNewAnimate(this.props.column, false);
  },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

handleRightClick: function handleRightClick(event) {

componentDidUpdate: function componentDidUpdate() {

cssAnimateHelper(this);
    this.animateObj.triggerAnimation(this.props.column);
    if ('' != this.props.column.getIn(['atts', 'bg_video_mp4_src']) || '' != this.props.column.getIn(['atts', 'bg_video_ogg_src']) || '' != this.props.column.getIn(['atts', 'bg_video_webm_src'])) {
      var bgVideoWrap = jQuery(this.refs.videoRef);
      fitVideoToContainer(bgVideoWrap);
    }
    if (this.triggerJs) {
      triggerJs('trigger_ready', true);
      this.triggerJs = false;
    }
    if (this.triggerParallax) {
      triggerJs('tatsu_column', true);
      this.triggerParallax = false;
    }
    if (this.triggerSticky) {
      triggerJs('tatsu_column', true, this.props.column.get('id'));
      this.triggerSticky = false;
    }
    if (this.triggerTilt) {
      triggerJs('tatsu_column', true, this.props.column.get('id'));
      this.triggerTilt = false;
    }
  },

componentDidMount: function componentDidMount() {

if ('' != this.props.column.getIn(['atts', 'bg_video_mp4_src']) || '' != this.props.column.getIn(['atts', 'bg_video_ogg_src']) || '' != this.props.column.getIn(['atts', 'bg_video_webm_src'])) {
      var bgVideoWrap = jQuery(this.refs.videoRef);
      fitVideoToContainer(bgVideoWrap);
    }
    if ('tilt' == this.props.column.getIn(['atts', 'column_hover_effect']) || '1' == this.props.column.getIn(['atts', 'sticky'])) {
      triggerJs('tatsu_column', true, this.props.column.get('id'));
    }
    this.animateObj.init();
  },

mouseEnterHandler: function mouseEnterHandler(event) {

var isMultiSelected = Immutable.List.isList(this.props.pathFromSelectionState.get(0)),
        selectionPath = this.props.pathFromSelectionState,
        curPath = this.props.path;
    if (-1 < document.body.className.indexOf("preview")) {
      return;
    }
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    if (!(isMultiSelected && selectionPath.contains(curPath) || Immutable.is(curPath, selectionPath))) {
      var title = this.props.moduleOptions.getIn([this.props.column.get('name'), 'title']) || this.props.column.get('name'),
          messageData = 'hover_set,' + this.props.column.get('id') + ',' + title;
      document.getElementById('tatsu-preview').contentWindow.postMessage(messageData, '*');
    }

this.setState({ hovered: true });
  },

mouseLeaveHandler: function mouseLeaveHandler() {

getLayoutClass: function getLayoutClass(layout) {

switch (layout) {

case '1/1':
        return 'tatsu-one-col';
      case '1/2':
        return 'tatsu-one-half';
      case '1/3':
        return 'tatsu-one-third';
      case '1/4':
        return 'tatsu-one-fourth';
      case '1/5':
        return 'tatsu-one-fifth';
      case '2/3':
        return 'tatsu-two-third';
      case '3/4':
        return 'tatsu-three-fourth';
      default:
        return '';

}
  },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

_handleAddModule: function _handleAddModule(event) {

getColumnClass: function getColumnClass(atts) {

if (!isEmpty(atts.get('overflow'))) {
      columnClass = columnClass + 'tatsu-prevent-overflow ';
    }

if (isEmpty(atts.get('bg_color')) && isEmpty(atts.get('bg_image')) && isEmpty(atts.get('overlay_color') || atts.get('overlay_blend_mode') === 'none')) {
      columnClass = columnClass + 'tatsu-column-no-bg ';
    }
    if ('' != this.props.column.getIn(['atts', 'bg_video_mp4_src']) || '' != this.props.column.getIn(['atts', 'bg_video_ogg_src']) || '' != this.props.column.getIn(['atts', 'bg_video_webm_src'])) {
      columnClass = columnClass + 'tatsu-video-section ';
    }
    if (!isEmpty(atts.get('overlay_color')) && atts.get('overlay_blend_mode') !== 'none') {
      columnClass = columnClass + 'tatsu-bg-overlay ';
    }
    if ('string' === typeof atts.get('column_class') && '' != atts.get('column_class')) {
      columnClass = columnClass + atts.get('column_class') + ' ';
    }
    if (!isEmpty(atts.get('vertical_align'))) {
      columnClass = columnClass + 'tatsu-column-align-' + atts.get('vertical_align') + ' ';
    }
    if (!isEmpty(atts.get('column_parallax'))) {
      columnClass = columnClass + 'tatsu-column-parallax ';
    }

return columnClass;
  },

getVideoMarkup: function getVideoMarkup(atts) {

return React.createElement(
      'video',
      { ref: 'videoRef', className: 'tatsu-bg-video', autoPlay: 'autoplay', loop: 'loop', muted: 'muted', preload: 'auto' },
      React.createElement('source', { src: atts.get('bg_video_mp4_src'), type: 'video/mp4' }),
      React.createElement('source', { src: atts.get('bg_video_ogg_src'), type: 'video/ogg' }),
      React.createElement('source', { src: atts.get('bg_video_webm_src'), type: 'video/webm' })
    );
  },

getOverlayMarkup: function getOverlayMarkup(atts, cssObject) {

var animateOverlayClass = '';
    if (!isEmpty(atts.get('animate_overlay'))) {
      animateOverlayClass = 'tatsu-animate-' + atts.get('animate_overlay');
    }

return React.createElement('div', { className: "tatsu-overlay tatsu-column-overlay" + animateOverlayClass, style: cssObject['.tatsu-column > .tatsu-column-inner > .tatsu-column-overlay'] });
  },

getTopShapeDivider: function getTopShapeDivider(atts, cssObject) {
    var topDivider = atts.get('top_divider'),
        topDividerClasses = [];
    if (tatsuConfig && !isEmpty(tatsuConfig.shape_dividers) && !isEmpty(tatsuConfig.shape_dividers.top) && !isEmpty(topDivider) && 'none' != topDivider) {
      topDividerClasses.push('tatsu-shape-divider', 'tatsu-top-divider');
      if (!isEmpty(atts.get('flip_top_divider'))) {
        topDividerClasses.push('tatsu-flip-divider');
      }
      topDividerClasses.push('tatsu-shape-over');
      topDividerClasses = topDividerClasses.join(' ');
      return React.createElement('div', { className: topDividerClasses, style: jQuery.extend({}, cssObject['.tatsu-top-divider'], cssObject['> .tatsu-column-inner > .tatsu-top-divider']), dangerouslySetInnerHTML: { __html: tatsuConfig.shape_dividers.top[topDivider] } });
    }
    return null;
  },

getBottomShapeDivider: function getBottomShapeDivider(atts, cssObject) {
    var bottomDivider = atts.get('bottom_divider'),
        bottomDividerClasses = [];
    if (tatsuConfig && !isEmpty(tatsuConfig.shape_dividers) && !isEmpty(tatsuConfig.shape_dividers.bottom) && !isEmpty(bottomDivider) && 'none' != bottomDivider) {
      bottomDividerClasses.push('tatsu-shape-divider', 'tatsu-bottom-divider');
      if (!isEmpty(atts.get('flip_bottom_divider'))) {
        bottomDividerClasses.push('tatsu-flip-divider');
      }
      bottomDividerClasses.push('tatsu-shape-over');
      bottomDividerClasses = bottomDividerClasses.join(' ');
      return React.createElement('div', { className: bottomDividerClasses, style: jQuery.extend({}, cssObject['.tatsu-bottom-divider'], cssObject['> .tatsu-column-inner > .tatsu-bottom-divider']), dangerouslySetInnerHTML: { __html: tatsuConfig.shape_dividers.bottom[bottomDivider] } });
    }
    return null;
  },

getLeftShapeDivider: function getLeftShapeDivider(atts, cssObject) {
    var leftDivider = atts.get('left_divider'),
        leftDividerStyleObject,
        leftDividerClasses = [];
    if (tatsuConfig && !isEmpty(tatsuConfig.shape_dividers) && !isEmpty(tatsuConfig.shape_dividers.left) && !isEmpty(leftDivider) && 'none' != leftDivider) {
      leftDividerClasses.push('tatsu-shape-divider', 'tatsu-left-divider');
      if (!isEmpty(atts.get('invert_left_divider'))) {
        leftDividerClasses.push('tatsu-invert-divider');
      }
      leftDividerClasses = leftDividerClasses.join(' ');
      leftDividerStyleObject = jQuery.extend({}, cssObject['.tatsu-left-divider'], cssObject['> .tatsu-column-inner > .tatsu-left-divider']);
      return React.createElement('div', { className: leftDividerClasses, style: leftDividerStyleObject, dangerouslySetInnerHTML: { __html: tatsuConfig.shape_dividers.left[leftDivider] } });
    }
    return null;
  },

getRightShapeDivider: function getRightShapeDivider(atts, cssObject) {
    var rightDivider = atts.get('right_divider'),
        rightDividerStyleObject,
        rightDividerClasses = [];
    if (tatsuConfig && !isEmpty(tatsuConfig.shape_dividers) && !isEmpty(tatsuConfig.shape_dividers.right) && !isEmpty(rightDivider) && 'none' != rightDivider) {
      rightDividerClasses.push('tatsu-shape-divider', 'tatsu-right-divider');
      if (!isEmpty(atts.get('invert_right_divider'))) {
        rightDividerClasses.push('tatsu-invert-divider');
      }
      rightDividerClasses = rightDividerClasses.join(' ');
      rightDividerStyleObject = jQuery.extend({}, cssObject['.tatsu-right-divider'], cssObject['> .tatsu-column-inner > .tatsu-right-divider']);
      return React.createElement('div', { className: rightDividerClasses, style: rightDividerStyleObject, dangerouslySetInnerHTML: { __html: tatsuConfig.shape_dividers.right[rightDivider] } });
    }
    return null;
  },

renderHelper: function renderHelper(atts, cssObject, columnClass, column, path, moduleOptions, gradientClass) {
    var idString = column.get('id'),
        children = column.get('inner'),
        columnId = atts.get('col_id'),
        columnIndex = path.last(),
        colsCount = this.props.parent.get('inner').size,
        imageHoverEffect = atts.get('image_hover_effect'),
        columnHoverEffect = atts.get('column_hover_effect'),
        gutter = atts.get('gutter'),
        columnSpacing = atts.has('column_spacing') ? atts.get('column_spacing') : '',
        columnMobileSpacing = atts.has('column_mobile_spacing') ? atts.get('column_mobile_spacing') : 0,
        columnPadStyling = cssObject['.tatsu-column > .tatsu-column-inner > .tatsu-column-pad-wrap > .tatsu-column-pad'],
        columnImageWrapper = cssObject['.tatsu-column > .tatsu-column-inner > .tatsu-column-bg-image-wrap > .tatsu-column-bg-image'],
        columnWrapStyle = jQuery.extend({}, cssObject['.tatsu-column'], cssObject['root']),
        columnStyle = cssObject['.tatsu-column > .tatsu-column-inner'],
        columnStyleHover = cssObject['.tatsu-column > .tatsu-column-inner:hover'];
    columnWrapStyle = jQuery.extend(true, {}, columnWrapStyle, cssObject['.tatsu-row > .tatsu-column']);

//sticky column vars
    var stickyClass = this.props.column.get('atts').get('sticky') === '1' ? 'tatsu-column-sticky' : '';

if (this.state.hovered) {
      columnStyle = jQuery.extend({}, columnStyle, columnStyleHover);
    }

if (!isEmpty(gutter) && 'custom' === gutter) {
      if ('undefined' != typeof columnSpacing) {
        columnSpacing = Number(columnSpacing.replace('px', '')) / 2 + 'px';
        columnWrapStyle.padding = '0 ' + columnSpacing;
      }
    }

if (this.props.targetDisplay === 'mobile' && atts.get('column_width') < 100 && columnMobileSpacing != 0) {
      columnMobileSpacing = Number(columnMobileSpacing.replace('px', '')) / 2 + 'px';
      columnWrapStyle.padding = '0 ' + columnMobileSpacing;
    }
    var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';

return React.createElement(
      'div',
      { onContextMenu: this.handleRightClick, id: 'string' === typeof columnId && '' != columnId ? columnId : null, style: columnWrapStyle, className: "tatsu-column be-preview " + tatsuHoverEffectClasses + " " + " tatsu-clearfix be-pb-observer-" + idString + columnClass + this.getLayoutClass(atts.get('layout')), 'data-parallax-speed': !isEmpty(atts.get('column_parallax')) ? atts.get('column_parallax') : 0, onMouseEnter: this.mouseEnterHandler, onMouseLeave: this.mouseLeaveHandler, onClick: routeHandler.bind(null, path) },
      -1 == document.body.className.indexOf("preview") && 'desktop' === this.props.targetDisplay && 0 != columnIndex ? React.createElement(
        'div',
        { onMouseEnter: this.showWidthDragger.bind(null, 'left'), onMouseLeave: this.hideWidthDragger, onMouseDown: this.initColWidthDrag.bind(null, [columnIndex - 1, columnIndex]), onMouseUp: this.props.resetCurDraggingCol, className: "tatsu-column-width-dragger tatsu-column-width-dragger-left " + ('left' === this.state.widthDragger.get('position') ? 'visible' : '') },
        React.createElement('div', { className: 'tatsu-column-width-dragger-inner' })
      ) : null,
      React.createElement(
        'div',
        { className: "tatsu-column-inner " + stickyClass + " " + gradientClass['.tatsu-column > .tatsu-column-inner'] + ' ' + (this.props.widthDraggerPlaceholderPosition ? 'tatsu-column-inner-width-drag' : ''), style: columnStyle },
        this.getTopShapeDivider(atts, cssObject),
        this.getLeftShapeDivider(atts, cssObject),
        React.createElement(
          'div',
          { className: 'tatsu-column-pad-wrap' },
          React.createElement(
            'div',
            { className: 'tatsu-column-pad', style: jQuery.extend({}, columnPadStyling, { borderWidth: '1px', borderStyle: 'dashed', borderColor: this.props.canDrop ? primaryColor : 'transparent' }) },
            this.renderColChildren(children, path, column, moduleOptions)
          )
        ),
        React.createElement('div', { className: "tatsu-column-bg-image", style: columnImageWrapper }),
        !isEmpty(atts.get('bg_video_mp4_src')) || !isEmpty(atts.get('bg_video_ogg_src')) || !isEmpty(atts.get('bg_video_webm_src')) ? this.getVideoMarkup(atts) : null,
        !isEmpty(atts.get('overlay_color')) && atts.get('overlay_blend_mode') !== 'none' ? this.getOverlayMarkup(atts, cssObject) : null,
        !isEmpty(atts.get('link_overlay')) ? React.createElement('a', { href: atts.get('link_overlay'), className: 'tatsu-col-overlay-link' }) : null,
        this.getRightShapeDivider(atts, cssObject),
        this.getBottomShapeDivider(atts, cssObject)
      ),
      this.props.widthDraggerPlaceholderPosition ? React.createElement(
        'div',
        { className: "tatsu-column-width-placeholder tatsu-column-width-placeholder-" + this.props.widthDraggerPlaceholderPosition },

// getAttFromDisplay( atts.get( 'column_width' ), this.props.targetDisplay )
        atts.get('column_width') + '%'
      ) : null,
      -1 == document.body.className.indexOf("preview") && ('desktop' !== this.props.targetDisplay || columnIndex !== colsCount - 1) ? React.createElement(
        'div',
        { onMouseEnter: this.showWidthDragger.bind(null, 'right'), onMouseLeave: this.hideWidthDragger, onMouseDown: this.initColWidthDrag.bind(null, [columnIndex, columnIndex + 1]), className: "tatsu-column-width-dragger tatsu-column-width-dragger-right " + ('right' === this.state.widthDragger.get('position') ? 'visible' : '') },
        React.createElement('div', { className: 'tatsu-column-width-dragger-inner' })
      ) : null
    );
  },

renderColChildren: function renderColChildren(children, path, column, moduleOptions) {

if (children.size === 0) {
      var style = { width: '100%', height: '200px', boxSizing: 'border-box', border: '1px dashed #a5a2a2' };
      return React.createElement(
        'div',
        { className: 'tatsu-empty-col', style: style, onClick: this._handleAddModule },
        React.createElement(
          'div',
          { id: 'tatsu-empty-col-add-tools-icon-wrapper' },
          React.createElement(
            'svg',
            { xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink', version: '1.1', x: '0px', y: '0px', viewBox: '0 0 100 100', style: { enableBackground: "new 0 0 100 100" }, xmlSpace: 'preserve' },
            React.createElement(
              'g',
              null,
              React.createElement('polygon', { points: '95.6,57.7 95.6,44.3 56.8,44.2 56.7,5.4 43.3,5.4 43.2,44.2 4.4,44.3 4.4,57.7 43.2,57.8 43.3,96.6 56.7,96.6    56.8,57.8  ' })
            )
          )
        )
      );
    } else {
      return children.map(function (module) {
        var modulePath = path;
        modulePath = modulePath.push(children.indexOf(module));
        return React.createElement(Module, { pathFromSelectionState: this.props.pathFromSelectionState, dropEffect: this.props.dropEffect, key: module.get('id'), targetDisplay: this.props.targetDisplay, path: modulePath, parent: column, module: module, moduleOptions: moduleOptions });
      }.bind(this));
    }
  },

render: function render() {
    var path = this.props.path,
        isOver = this.props.isOver,
        column = this.props.column,
        moduleName = column.get('name'),
        connectDropTarget = this.props.connectDropTarget,
        moduleOptions = this.props.moduleOptions,
        attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']),
        atts = getAttsBasedOnTargetDisplay(column.get('atts'), this.props.targetDisplay, attsFromModuleOptions),
        moduleStyles = getModuleStyle(column, this.props.targetDisplay, moduleOptions),
        cssObject = getConcatenatedCSS(moduleStyles),
        columnClass = this.getColumnClass(atts);

return connectDropTarget(this.renderHelper(atts, cssObject.style, columnClass, column, path, moduleOptions, cssObject.class));
  }

});

module.exports = flow(DropTarget(dndScope.module, dropSpec, collect))(Column);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 218 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _divider = __webpack_require__(606);

var _divider2 = _interopRequireDefault(_divider);

var _menu = __webpack_require__(91);

var _menu2 = _interopRequireDefault(_menu);

__webpack_require__(607);

__webpack_require__(92);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var store = __webpack_require__(11),
    setSelection = __webpack_require__(2).setSelection,
    triggerCopyOrCut = __webpack_require__(2).triggerCopyOrCut,
    focusHiddenInput = __webpack_require__(708),
    copyAttributes = __webpack_require__(2).copyAttributes,
    pasteAttributes = __webpack_require__(2).pasteAttributes,
    openDrawer = __webpack_require__(2).openDrawer,
    closeContextMenu = __webpack_require__(2).closeContextMenu,
    deleteModule = __webpack_require__(2).deleteModule,
    sendMessage = __webpack_require__(2).sendMessage,
    duplicate = __webpack_require__(2).duplicate,
    addModule = __webpack_require__(2).addModule,
    encodePath = __webpack_require__(43).encodePath,
    routeResolve = __webpack_require__(33),
    BePopOver = __webpack_require__(155).default,
    shortid = __webpack_require__(116);

var Item = _menu2.default.Item,
    SubMenu = _menu2.default.SubMenu;

var ContextMenu = React.createClass({
	displayName: 'ContextMenu',

_handleRequestClose: function _handleRequestClose() {

store.dispatch(closeContextMenu());
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

return !Immutable.is(this.props.contextMenuState, nextProps.contextMenuState);
	},

_handleCopy: function _handleCopy() {

_getCopyPasteMenus: function _getCopyPasteMenus() {

return this._getMenuItemMarkUp({
					name: 'multi',
					items: ['Divider', 'Copy Styles'] });
			}
		}
		return null;
	},

_getMenuItemMarkUp: function _getMenuItemMarkUp(menuItems) {

var shortcuts = {
			'Cut': '&#8984; X',
			'Copy': '&#8984; C',
			'Paste': '&#8984; V',
			'Delete': '&#8984; &#8592;',
			'Duplicate': '&#8984; D',
			'Paste Styles': '&#8984; Shft V',
			'Copy Styles': '&#8984; Shft C'
		},
		    moduleName = menuItems.name,
		    items = menuItems.items,
		    itemsMarkUp = [];

for (var item in items) {
			if (items[item] === 'colcontainers') {
				if (5 <= this.props.contextMenuState.get('path').size || 'tatsu_inner_row' == this.props.contextMenuState.get('name')) {
					itemsMarkUp.push(React.createElement(
						SubMenu,
						{ key: shortid.generate(), title: 'Manage Columns', className: 'be-menu-submenu' },
						this._getMenuItemMarkUp({
							name: '',
							items: ['Inner Column', 'Column'] })
					));
				} else {
					itemsMarkUp.push(this._getMenuItemMarkUp({
						name: '',
						items: ['Manage Column'] }));
				}
			} else if (items[item] === 'Divider') {
				itemsMarkUp.push(React.createElement(_divider2.default, null));
			} else {
				var tempMarkup = React.createElement(
					Item,
					{ key: items[item] },
					React.createElement(
						'div',
						{ className: 'tatsu-context-menu-list-wrap' },
						React.createElement(
							'div',
							{ className: 'tatsu-list-item-primary' },
							items[item]
						),
						shortcuts.hasOwnProperty(items[item]) && React.createElement('div', { className: 'tatsu-list-item-secondary', dangerouslySetInnerHTML: { __html: shortcuts[items[item]] } })
					)
				);

itemsMarkUp.push(tempMarkup);
			}
		}
		return itemsMarkUp;
	},

_getCurrentMenus: function _getCurrentMenus() {
		var currentModuleName = this.props.contextMenuState.get('name'),
		    builderMode = this.props.builderMode,
		    menuItemsArray = [],
		    copyPasteMenu = this._getCopyPasteMenus();

switch (currentModuleName) {
			case 'Multiple Selection':
				menuItemsArray = this._getMenuItemMarkUp({
					name: 'tatsu_row',
					items: ['Cut', 'Copy', 'Divider', 'Delete', 'Duplicate'] });
				break;
			case 'tatsu_section':
				//show add section, add row
				//cannot show switch columns, add module
				menuItemsArray = this._getMenuItemMarkUp({
					name: 'tatsu_row',
					items: ['Cut', 'Copy', 'Divider', 'Delete', 'Duplicate', 'Add Section', 'Add Row', 'Divider', 'Save As Template', 'Edit'] });
				break;
			case 'tatsu_row':
				//show add section, switch columns, add row
				//cannot show add module

menuItemsArray = this._getMenuItemMarkUp({
					name: 'tatsu_row',
					items: ['Cut', 'Copy', 'Divider', 'Delete', 'Duplicate', 'Add Section', 'Add Row', 'Divider', 'Edit'] });
				break;
			case 'tatsu_column':
			case 'tatsu_inner_column':
				//show column switch, add row, add secion, add module

menuItemsArray = this._getMenuItemMarkUp({
					name: 'tatsu_column',
					items: ['Cut', 'Copy', 'Delete', 'Divider', 'Add Section', 'Add Row', 'Add Module', 'Divider', 'Manage Column', 'Edit'] });
				break;
			case 'tatsu_header_row':
				//show column switch, add row, add secion, add module

menuItemsArray = this._getMenuItemMarkUp({
					name: 'module',
					items: ['Cut', 'Copy', 'Divider', 'Delete', 'Duplicate', 'Add Header Row', 'Divider', 'Edit'] });

break;
			case 'tatsu_header_column':
				//show column switch, add row, add secion, add module

menuItemsArray = this._getMenuItemMarkUp({
					name: 'tatsu_header_column',
					items: ['Cut', 'Copy', 'Divider', 'Edit', 'Add Header Row', 'Add Module', 'Divider', 'Manage Header Columns'] });
				break;
			default:
				//show add section, add row, switch columns, add module

if ('header_builder' === builderMode) {

menuItemsArray = this._getMenuItemMarkUp({
						name: 'header_module',
						items: ['Cut', 'Copy', 'Duplicate', 'Delete', 'Divider', 'Add Header Row', 'Add Module', 'Divider', 'Edit', 'colcontainers'] });
				} else {

menuItemsArray = this._getMenuItemMarkUp({
						name: 'module',
						items: ['Cut', 'Copy', 'Duplicate', 'Delete', 'Divider', 'Add Section', 'Add Row', 'Add Module', 'Divider', 'Edit', 'colcontainers'] });
				}
				break;

}
		if (null != copyPasteMenu && 0 < copyPasteMenu.length) {
			copyPasteMenu.forEach(function (menuComp) {

menuItemsArray.push(menuComp);
			});
		}
		return menuItemsArray;
	},

_handleItemTouchTap: function _handleItemTouchTap(menuItem) {

var path = this.props.contextMenuState.get('path'),
		    clientRect = this.props.contextMenuState.get('clientRect'),
		    drawerMeta,
		    webkitScrollTop = document.getElementById('tatsu-preview').contentDocument.body.scrollTop,
		    mozScrollTop = document.getElementById('tatsu-preview').contentDocument.getElementsByTagName('html')[0].scrollTop,
		    currentScrollPosition = webkitScrollTop > mozScrollTop ? webkitScrollTop : mozScrollTop,
		    moduleName = this.props.contextMenuState.get('name');

// store.dispatch( 
		// 	changeTargetDisplay( 'desktop' ) 
		// );
		switch (menuItem.key) {

case 'Add Section':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				store.dispatch(addModule(path.slice(0, 1), 'tatsu_section', 'insert', 'bottom'));
				store.dispatch(closeContextMenu());
				break;
			case 'Save As Template':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				var drawerMeta = Immutable.Map({
					action: 'save',
					saveType: 'sections',
					path: path
				});
				store.dispatch(openDrawer('template', drawerMeta));
				store.dispatch(closeContextMenu());
				break;
			case 'Add Row':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				if ('tatsu_section' == moduleName) {
					store.dispatch(addModule(path, 'tatsu_row', 'push'));
					store.dispatch(closeContextMenu());
				} else {
					store.dispatch(addModule(path.slice(0, 2), 'tatsu_row', 'insert', 'bottom'));
					store.dispatch(closeContextMenu());
				}
				break;
			case 'Add Header Row':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				store.dispatch(addModule(path.slice(0, 1), 'tatsu_header_row', 'insert', 'bottom'));
				store.dispatch(closeContextMenu());
				break;
			case 'Add Module':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				drawerMeta = Immutable.Map({
					path: path,
					position: 'bottom',
					addType: this.props.contextMenuState.get('builderType') === 'core' ? 'push' : 'insert'
				});
				store.dispatch(openDrawer('modulelist', drawerMeta));
				store.dispatch(closeContextMenu());
				break;
			case 'Delete':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				store.dispatch(deleteModule(path, moduleName));
				store.dispatch(closeContextMenu());
				break;
			case 'Duplicate':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				store.dispatch(duplicate(path, moduleName));
				store.dispatch(closeContextMenu());
				break;
			case 'Manage Column':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				var rowPath = path.slice(0, 2);
				this._handleEdit(rowPath, 'layoutManager');
				store.dispatch(closeContextMenu());
				break;
			case 'Edit':
				var hasDragHandle = this.props.moduleOptions.getIn([moduleName, 'drag_handle']) || false;
				this._handleEdit(path, 'moduleEditor');
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				// store.dispatch(
				// 	setSelection( path )
				// );
				store.dispatch(closeContextMenu());
				break;
			case 'Paste':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				store.dispatch(sendMessage(Immutable.Map({ type: 'paste', message: 'Click on a module and then press Ctrl/Cmd + V to Paste' }), 'popUp'));
				store.dispatch(closeContextMenu());
				break;
			case 'Copy Styles':
				store.dispatch(copyAttributes());
				store.dispatch(closeContextMenu());
				break;
			case 'Paste Styles':
				store.dispatch(pasteAttributes());
				store.dispatch(closeContextMenu());
				break;
			case 'Copy':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				store.dispatch(triggerCopyOrCut(path, 'copy'));
				store.dispatch(closeContextMenu());
				break;
			case 'Cut':
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				store.dispatch(triggerCopyOrCut(path, 'cut'));
				store.dispatch(closeContextMenu());
				break;
			case 'Section':
				var sectionPath = path.slice(0, 1);
				this._handleEdit(sectionPath, 'moduleEditor');
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				// store.dispatch(
				// 	setSelection( sectionPath )
				// );
				store.dispatch(closeContextMenu());
				break;
			case 'Row':
				var rowPath = path.slice(0, 2);
				this._handleEdit(rowPath, 'moduleEditor');
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				// store.dispatch(
				// 	setSelection( rowPath )
				// );
				store.dispatch(closeContextMenu());
				break;
			case 'Header Row':
				var headerRowPath = path.slice(0, 1);
				this._handleEdit(headerRowPath, 'moduleEditor');
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				// store.dispatch(
				// 	setSelection( rowPath )
				// );
				store.dispatch(closeContextMenu());
				break;
			case 'Column':
				var columnPath = path.slice(0, 2);
				this._handleEdit(columnPath, 'moduleEditor');
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				// store.dispatch(
				// 	setSelection( columnPath )
				// );
				store.dispatch(closeContextMenu());
				break;
			case 'Header Column':
				var columnPath = path.slice(0, 2);
				this._handleEdit(columnPath, 'moduleEditor');
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				// store.dispatch(
				// 	setSelection( columnPath )
				// );
				store.dispatch(closeContextMenu());
				break;
			case 'Inner Row':
				var innerRowPath = path.slice(0, 4);
				this._handleEdit(innerRowPath, 'moduleEditor');
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				// store.dispatch(
				// 	setSelection( innerRowPath )
				// );
				store.dispatch(closeContextMenu());
				break;
			case 'Inner Column':
				var columnPath = path.slice(0, 4);
				this._handleEdit(columnPath, 'moduleEditor');
				if (-1 < document.body.className.indexOf('mce-fullscreen')) {
					tinymce.activeEditor.execCommand('mceFullScreen');
				}
				// store.dispatch(
				// 	setSelection( columnPath )
				// );
				store.dispatch(closeContextMenu());
				break;
			default:
				break;

}
	},

_handleEdit: function _handleEdit(path, routeType) {

var serializedPath = encodePath(path.toArray().toString()),
		    inputElement = document.getElementById('tatsu-preview').contentDocument.getElementById('tatsu-copy-paste-helper'),
		    webkitScrollTop = document.getElementById('tatsu-preview').contentDocument.body.scrollTop,
		    inputElement = document.getElementById('tatsu-preview').contentDocument.getElementById('tatsu-copy-paste-helper'),
		    mozScrollTop = document.getElementById('tatsu-preview').contentDocument.getElementsByTagName('html')[0].scrollTop,
		    currentScrollPosition = webkitScrollTop > mozScrollTop ? webkitScrollTop : mozScrollTop,
		    rootRoute = routeResolve(window.location.pathname);

store.dispatch(setSelection(path, 'single'));
		setTimeout(function () {
			if (null != inputElement) {
				inputElement.style.top = currentScrollPosition + 10 + 'px';
			}
			focusHiddenInput();
		}, 250);
	},

render: function render() {

var contextMenuState = this.props.contextMenuState,
		    isOpen = contextMenuState.get('open'),
		    top,
		    left,
		    path,
		    mockAnchroEl,
		    threshold,
		    moduleName,
		    targetVerticalOrigin = 'top',
		    moduleTitle;

if (isOpen) {
			top = contextMenuState.get('top');
			left = contextMenuState.get('left');
			path = contextMenuState.get('path');
			moduleName = contextMenuState.get('name');
			moduleTitle = contextMenuState.get('title'), mockAnchroEl = {
				getBoundingClientRect: function getBoundingClientRect() {
					return {
						top: Number(top),
						left: Number(left)
					};
				},
				offsetWidth: 336,
				offsetHeight: 1
			};
		}
		if ('tatsu_section' == moduleName || 'tatsu_row' == moduleName) {
			threshold = 425;
		} else if ('tatsu_column' == moduleName || 'tatsu_inner_column' == moduleName) {
			threshold = 471;
		} else {
			threshold = 502;
		}
		if (window.innerHeight - top < threshold) {
			targetVerticalOrigin = 'bottom';
		}

return React.createElement(
			BePopOver,
			{ width: '200px', handleClickAway: this._handleRequestClose, open: isOpen, anchorCoords: { top: top + 'px', left: left - 300 + 'px' }, wrapWithinViewport: true },
			React.createElement(
				_menu2.default,
				{ mode: 'vertical', style: { width: '100%', borderRight: '0' }, selectable: false, onClick: this._handleItemTouchTap, className: 'be-ui-component be-menu', getPopupContainer: function getPopupContainer(triggerNode) {
						return triggerNode.parentNode;
					} },
				this._getCurrentMenus()
			)
		);
	}

});
exports.default = ContextMenu;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 219 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var mapChecker = __webpack_require__(16).mapChecker,
    store = __webpack_require__(11),
    initialStateData = __webpack_require__(379),
    DragLayer = __webpack_require__(37).DragLayer;
function collect(monitor) {
  return {
    module: monitor.getItem(),
    itemType: monitor.getItemType(),
    isDragging: monitor.isDragging(),
    initialOffset: monitor.getInitialSourceClientOffset(),
    currentOffset: monitor.getClientOffset()
  };
}

var CustomDragLayer = React.createClass({
  displayName: 'CustomDragLayer',

windowHeight: window.innerHeight - 100,
  propTypes: {

dropEffect: React.PropTypes.string,
    selectionState: mapChecker,
    module: function module(props, propName, componentName) {
      if (props.isDragging) {
        mapChecker(props, propName, componentName);
      }
    },
    isDragging: React.PropTypes.bool.isRequired,
    initialOffset: function initialOffset(props, propName, componentName) {
      if (props.isDragging) {
        if (_typeof(props.initialOffset) != 'object') {
          return new Error('Initial Offset should be an object');
        }
      }
    },
    currentOffset: function currentOffset(props, propName, componentName) {
      if (props.isDragging) {
        if (_typeof(props.currentOffset) != 'object') {
          return new Error('Current Offset should be an object');
        }
      }
    }

getStyle: function getStyle() {

if (this.props.currentOffset) {
      var x = this.props.currentOffset.x || 0,
          y = this.props.currentOffset.y || 0,
          transform;

x = x - 25;
      y = y - 25;
      transform = 'translate(' + x + 'px,' + y + 'px)';
      return {
        position: 'fixed',
        pointerEvents: 'none',
        cursor: 'none',
        zIndex: '100000',
        top: '0',
        left: '0',
        transform: transform,
        WebkitTransform: transform
      };
    }
  },

iconAdder: function iconAdder() {

render: function render() {

/***/ }),
/* 220 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

var mapChecker = __webpack_require__(16).mapChecker,
    DropPlaceholder = React.createClass({
    displayName: 'DropPlaceholder',

propTypes: {
        dragMonitor: mapChecker
    },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

return !Immutable.is(this.props.dragMonitor, nextProps.dragMonitor);
    },

render: function render() {

var top = this.props.dragMonitor.get('top'),
            left = this.props.dragMonitor.get('left'),
            width = this.props.dragMonitor.get('width'),
            draggedModulePath = this.props.dragMonitor.get('path'),
            draggedModuleName = this.props.dragMonitor.get('name'),
            primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff50' : '#1b86f150',
            comStyle = {
            top: top + 'px',
            left: left + 'px',
            width: width + 'px',
            display: 0 == draggedModulePath.size ? 'none' : 'inline-block',
            height: 'tatsu_column' == draggedModuleName || 'tatsu_inner_column' == draggedModuleName ? '200px' : '',
            borderRadius: 'tatsu_column' == draggedModuleName || 'tatsu_inner_column' == draggedModuleName ? '0px' : '',
            background: 'tatsu_inner_row' == draggedModuleName ? '#07e689' : primaryColor
        };
        return React.createElement('div', { style: comStyle, className: 'tatsu-drag-observer' });
    }

});
module.exports = DropPlaceholder;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 221 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

var _tooltip = __webpack_require__(58);

var _tooltip2 = _interopRequireDefault(_tooltip);

__webpack_require__(59);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var React = __webpack_require__(0),
    getBookmark = __webpack_require__(32).getBookmark,
    moveToBookmark = __webpack_require__(32).moveToBookmark,
    getNeededStyleValue = __webpack_require__(32).getNeededStyleValue;

var FontToolView = React.createClass({
    displayName: 'FontToolView',

currentBookMark: null,
    typehubSelectorsList: [],
    getInitialState: function getInitialState() {

return {
            fontSize: false,
            letterSpacing: false,
            lineHeight: false,
            typehubSelectors: false
        };
    },

_getCurrentClass: function _getCurrentClass() {

return getNeededStyleValue(this.props.activeEditorId, 'class');
    },

loadTypehubSelectors: function loadTypehubSelectors() {

if (window.typehub_selectors && window.typehub_selectors.constructor === Object) {
            var typehubSelectors = window.typehub_selectors,
                typehubSelectorsArray = Object.keys(typehubSelectors),
                currentClassName = this.props.currentTypehubSelector;
            this.typehubSelectorsList = typehubSelectorsArray.map(function (selector) {
                return React.createElement(
                    'div',
                    { className: 'tatsu-inline-typehub-selector', style: { color: currentClassName === selector ? '#32ccd5' : 'inherit' }, onClick: function (event) {
                            var curBookMark = this.currentBookMark;
                            this.currentBookMark = null;
                            moveToBookmark(curBookMark, this.props.activeEditorId);
                            this.props.applyClass(selector, 'typehub');
                            this.props.useOverride(false);
                        }.bind(this) },
                    ' ',
                    typehubSelectors[selector],
                    ' '
                );
            }.bind(this));
        } else {
            this.typehubSelectorsList = React.createElement(
                'div',
                null,
                ' No Selectors found '
            );
        }
    },

componentDidUpdate: function componentDidUpdate() {

if (this.state.fontSize) {
            var actualFontSize = this.props.currentFontSize;
            if (actualFontSize != this.refs.fontSize.value) {
                this.refs.fontSize.value = actualFontSize;
            }
        } else if (this.state.lineHeight) {
            var actualLineHeight = this.props.currentLineHeight;
            if (actualLineHeight != this.refs.lineHeight.value) {
                this.refs.lineHeight.value = actualLineHeight;
            }
        } else if (this.state.letterSpacing) {
            var actualLetterSpacing = this.props.currentLetterSpacing;
            if (actualLetterSpacing != this.refs.letterSpace.value) {
                this.refs.letterSpace.value = actualLetterSpacing;
            }
        }
    },

_toggleState: function _toggleState(type) {

_handleF: function _handleF(event) {

event.preventDefault();
    },

_handleMouseDown: function _handleMouseDown(event) {

if (this.currentBookMark) {
            var curBookmark = this.currentBookMark;
            this.currentBookMark = null;
            moveToBookmark(curBookmark, this.props.activeEditorId);
            this.props.useOverride(false);
        }
        event.stopPropagation();
        event.preventDefault();
    },

_handleActualBlur: function _handleActualBlur() {

if (this.currentBookMark) {
            this.currentBookMark = null;
            this.props.resetState();
        }
    },

_handleBlur: function _handleBlur(event) {

setTimeout(this._handleActualBlur, 0);
    },

_handleClick: function _handleClick(tool, event) {

event.preventDefault();
        event.stopPropagation();
        this._toggleState(tool);
    },

_handleInputMouseDown: function _handleInputMouseDown(event) {

if (!this.props.isOverriden) {
            this.currentBookMark = getBookmark(this.props.activeEditorId);
            this.props.useOverride(true);
        }
        event.stopPropagation();
    },

_handleKeyUp: function _handleKeyUp(fontStyleProp, event) {

if (this.currentBookMark && 13 == event.which) {
            var currentValue = event.target.value + 'px',
                curBookMark = this.currentBookMark;
            this.currentBookMark = null;
            moveToBookmark(curBookMark, this.props.activeEditorId);
            this.props.applyProp(fontStyleProp, currentValue);
            this.props.useOverride(false);
        }
    },

_preventDefault: function _preventDefault(event) {

event.preventDefault();
    },

_toggleBlockType: function _toggleBlockType(heading, event) {

event.stopPropagation();
        this.props.toggleBlockType(heading);
    },

_preventPropagation: function _preventPropagation(event) {

event.stopPropagation();
    },

_preventDefaultAndStopPropagation: function _preventDefaultAndStopPropagation(event) {

event.preventDefault();
        event.stopPropagation();
    },

_toggleFont: function _toggleFont(event) {

event.preventDefault();
        event.stopPropagation();
        this.props.toggleTool('font');
    },

render: function render() {
        var blockTypesArray = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],
            blockTypesList = [];

var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';

blockTypesList = blockTypesArray.map(function (item) {
            return React.createElement(
                'div',
                { className: 'tatsu-inline-button', onClick: this._toggleBlockType.bind(null, item), onMouseDown: this._handleMouseDown, onMouseUp: this._preventDefault, style: { minWidth: '35px', height: '35px', letterSpacing: '1px', borderRight: '1px solid #32373d', color: item == this.props.blockType ? primaryColor : '#c4c4c4' } },
                ' ',
                item.toUpperCase()
            );
        }.bind(this));

});

module.exports = FontToolView;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 222 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

var React = __webpack_require__(0),
    findDOMNode = __webpack_require__(7).findDOMNode,
    store = __webpack_require__(11),
    frameLoaded = __webpack_require__(2).frameLoaded,
    HeaderBuilderNavBar = __webpack_require__(223),
    ReactDOM = __webpack_require__(7);
var FrameContent = React.createClass({
    displayName: 'FrameContent',

getChildContext: function getChildContext() {
        return this.props.context;
    },
    render: function render() {
        return React.createElement(
            'div',
            null,
            this.props.children
        );
    }
});
FrameContent.childContextTypes = {
    dragDropManager: React.PropTypes.object.isRequired
};
var Frames = React.createClass({
    displayName: 'Frames',

handler2: function handler2(conte) {
        if (this.props.frameLoaded) {
            var iframeDocument,
                body,
                absoluteWrapper,
                content1,
                targetDisplay = this.props.targetDisplay;
            if ('tablet' === targetDisplay || 'mobile' === targetDisplay && 'header_builder' !== this.props.builderMode) {
                iframeDocument = findDOMNode(this).children[0].children[1].contentDocument;
            } else if ('mobile' === targetDisplay && 'header_builder' === this.props.builderMode) {
                iframeDocument = findDOMNode(this).children[0].children[2].contentDocument; //Added a separate Nav Bar for Mobile Layout in Header Builder
            } else {
                iframeDocument = findDOMNode(this).children[0].children[0].contentDocument;
            }
            body = iframeDocument.getElementsByTagName('body')[0];
            content1 = iframeDocument.getElementById('tatsu-content-wrap');
            absoluteWrapper = iframeDocument.getElementById('tatsu-absolute-wrapper');
            if (null != content1) {
                ReactDOM.render(React.createElement(
                    FrameContent,
                    { context: conte },
                    React.Children.map(this.props.children, function (currentChild, index) {
                        return currentChild && 'undefined' == typeof currentChild.props.isAbsolute ? currentChild : null;
                    })
                ), content1);
                if (null != absoluteWrapper && !(this.props.builderMode === 'header_builder' && targetDisplay === 'mobile')) {
                    ReactDOM.render(React.createElement(
                        FrameContent,
                        { context: conte },
                        React.Children.map(this.props.children, function (currentChild, index) {

return true === currentChild.props.isAbsolute ? currentChild : null;
                        })
                    ), absoluteWrapper);
                }
            } else {
                return;
            }
        }
    },
    renderInComplete: function renderInComplete() {
        store.dispatch(frameLoaded());
    },
    renderComplete: function renderComplete() {
        store.dispatch(frameLoaded());
    },

handler: function handler(conte) {
        var self = this,
            dragDropManager = conte,
            targetDisplay = this.props.targetDisplay,
            $this = jQuery(findDOMNode(this));
        $this.find('#tatsu-preview').on('load', function () {
            var body = this.contentDocument.getElementsByTagName('body')[0],
                absoluteWrapper = this.contentDocument.getElementById('tatsu-absolute-wrapper'),
                content1 = this.contentDocument.getElementById('tatsu-content-wrap');
            window.dragDropManager = dragDropManager;
            dragDropManager.dragDropManager.backend.addEventListeners(body);
            if (null != content1) {
                ReactDOM.render(React.createElement(
                    FrameContent,
                    { context: conte },
                    React.Children.map(self.props.children, function (currentChild, index) {

return 'undefined' == typeof currentChild.props.isAbsolute ? currentChild : null;
                    })
                ), content1, self.renderComplete);
                if (null != absoluteWrapper && !(self.props.builderMode === 'header_builder' && targetDisplay === 'mobile')) {
                    ReactDOM.render(React.createElement(
                        FrameContent,
                        { context: conte },
                        React.Children.map(self.props.children, function (currentChild, index) {

return true === currentChild.props.isAbsolute ? currentChild : null;
                        })
                    ), absoluteWrapper);
                }
            } else {
                self.renderInComplete();
            }
        });
    },

appendQueryString: function appendQueryString(url, queryVars) {
        var firstSeperator = url.indexOf('?') == -1 ? '?' : '&';
        var queryStringParts = new Array();
        for (var key in queryVars) {
            queryStringParts.push(key + '=' + queryVars[key]);
        }
        var queryString = queryStringParts.join('&');
        return url + firstSeperator + queryString;
    },

render: function render() {
        var iframeUrl = tatsuConfig.post_permalink,
            targetDisplay = this.props.targetDisplay,
            queryStringUrl = this.appendQueryString(iframeUrl, { 'tatsu-frame': '1', 'post_id': tatsuConfig.post_id });
        return React.createElement(
            'div',
            { className: "iframe-wrapper " + targetDisplay },
            React.createElement(
                'div',
                { className: 'iframe-responsive-wrap' },
                this.props.builderMode === 'header_builder' && targetDisplay === 'mobile' ? React.createElement(HeaderBuilderNavBar, { targetDisplay: this.props.targetDisplay, selectionState: this.props.selectionState, moduleOptions: this.props.moduleOptions }) : null,
                'mobile' === targetDisplay || 'tablet' === targetDisplay ? React.createElement(
                    'div',
                    { className: 'tatsu-mobile-top-design-wrap' },
                    React.createElement('div', { className: 'tatsu-mobile-top-dot' }),
                    React.createElement('div', { className: 'tatsu-mobile-top-rect' })
                ) : null,
                React.createElement('iframe', { id: 'tatsu-preview', src: queryStringUrl }),
                'mobile' === targetDisplay || 'tablet' === targetDisplay ? React.createElement('div', { className: 'tatsu-mobile-bottom-button' }) : null
            )
        );
    },

componentDidMount: function componentDidMount() {
        this.handler(this.context);
    },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        if ('module' == nextProps.dragType && !this.props.isDragging && nextProps.isDragging) {
            this.context.dragDropManager.backend.removeEventListeners(window);
        }
        if ('module' == this.props.dragType && this.props.isDragging && !nextProps.isDragging) {
            this.context.dragDropManager.backend.addEventListeners(window);
        }
    },

componentDidUpdate: function componentDidUpdate() {
        this.handler2(this.context);
    }

});

Frames.contextTypes = {

dragDropManager: React.PropTypes.object.isRequired

};

module.exports = Frames;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 223 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var keyPath = __webpack_require__(39),
    deleteModule = __webpack_require__(2).deleteModule,
    duplicate = __webpack_require__(2).duplicate,
    addSelectedStyle = __webpack_require__(80).addSelectedStyle,
    removeSelectedStyle = __webpack_require__(80).removeSelectedStyle,
    store = __webpack_require__(11),
    setSelection = __webpack_require__(2).setSelection,
    getPathFromSelectionState = __webpack_require__(97),
    HeaderBuilderNavBar = React.createClass({
    displayName: 'HeaderBuilderNavBar',

shouldComponentUpdate: function shouldComponentUpdate(nextProps) {

var result = false;
        result = !Immutable.is(this.props.selectionState, nextProps.selectionState);
        return result;
    },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

if (this.props.selectionState != nextProps.selectionState) {

var previousSelectedModules = this.props.selectionState.get('selectionList');
            0 == previousSelectedModules.size ? null : previousSelectedModules.map(function (curSelection, index) {
                removeSelectedStyle(curSelection.get('id'));
            }.bind(this));

var currentSelectedModules = nextProps.selectionState.get('selectionList');
            0 == currentSelectedModules.size ? null : currentSelectedModules.map(function (curSelection, index) {
                addSelectedStyle(curSelection.get('id'));
            }.bind(this));
        }
    },

triggerTool: function triggerTool(tool, path, name) {

if ('multi' == this.props.selectionState.get('type')) {
            var pathList = this.props.selectionState.get('selectionList').map(function (curSelection) {
                return curSelection.get('path');
            });
            if ('delete' == tool) {
                store.dispatch(deleteModule(pathList, 'Multiple Selection'));
            } else if ('duplicate' == tool) {
                store.dispatch(duplicate(pathList, 'Multiple Selection'));
            }
        } else {
            if ('delete' == tool) {
                store.dispatch(deleteModule(path, name));
            } else if ('duplicate' == tool) {
                store.dispatch(duplicate(path, name));
            }
        }
        return null;
    },

getObserverTools: function getObserverTools(path, name) {
        var availableTools = ['duplicate', 'delete'];
        if ('tatsu_header_column' == name) {
            availableTools = ['delete'];
        }
        return availableTools.map(function (tool, index) {
            return React.createElement(
                'div',
                { className: 'tatsu-header-tool', onClick: this.triggerTool.bind(null, tool, path, name) },
                'duplicate' == tool ? React.createElement(
                    'svg',
                    { style: { width: '20px', height: '20px', fill: '#fff' }, viewBox: '0 0 100 100' },
                    React.createElement('path', { d: 'M86,14H27.5v58.5H86V14z M80.1,66.6H33.4V19.9h46.7V66.6z M69.5,86H14V30.5h5.9v49.7h49.7V86z M53.8,46.2  H42.4v-5.9h11.4V28.9h5.9v11.4h11.4v5.9H59.7v11.4h-5.9V46.2z' })
                ) : React.createElement(
                    'svg',
                    { style: { width: '22px', height: '22px', fill: '#fff' }, viewBox: '0 0 100 100' },
                    React.createElement('path', { d: 'M67.6683908,76.9065599 C67.632523,77.7673863 66.8667215,78.5 65.9999745,78.5 L34.0000255,78.5 C33.1336268,78.5 32.3673911,77.7653262 32.3316092,76.9065599 L30.4978327,32.8959236 C30.4403529,31.5164087 29.2754385,30.4446875 27.8959236,30.5021673 C26.5164087,30.5596471 25.4446875,31.7245615 25.5021673,33.1040764 L27.3359438,77.1147127 C27.4833334,80.6520627 30.453619,83.5 34.0000255,83.5 L65.9999745,83.5 C69.5442642,83.5 72.5164778,80.6565944 72.6640562,77.1147127 L74.4978327,33.1040764 C74.5553125,31.7245615 73.4835913,30.5596471 72.1040764,30.5021673 C70.7245615,30.4446875 69.5596471,31.5164087 69.5021673,32.8959236 L67.6683908,76.9065599 Z M48,71 C48,72.1045695 48.8954305,73 50,73 C51.1045695,73 52,72.1045695 52,71 L52,37 C52,35.8954305 51.1045695,35 50,35 C48.8954305,35 48,35.8954305 48,37 L48,71 Z M38.0008645,71.0587981 C38.0333378,72.1628902 38.954706,73.0316088 40.0587981,72.9991355 C41.1628902,72.9666622 42.0316088,72.045294 41.9991355,70.9412019 L40.9991355,36.9412019 C40.9666622,35.8371098 40.045294,34.9683912 38.9412019,35.0008645 C37.8371098,35.0333378 36.9683912,35.954706 37.0008645,37.0587981 L38.0008645,71.0587981 Z M58.0008645,70.9412019 C57.9683912,72.045294 58.8371098,72.9666622 59.9412019,72.9991355 C61.045294,73.0316088 61.9666622,72.1628902 61.9991355,71.0587981 L62.9991355,37.0587981 C63.0316088,35.954706 62.1628902,35.0333378 61.0587981,35.0008645 C59.954706,34.9683912 59.0333378,35.8371098 59.0008645,36.9412019 L58.0008645,70.9412019 Z M62.314325,22 L61.3628045,18.6696783 C60.5262772,15.741833 57.5532275,13.5 54.5085033,13.5 L45.4914967,13.5 C42.4471337,13.5 39.4734928,15.742638 38.6371955,18.6696783 L37.685675,22 L25,22 C23.6192881,22 22.5,23.1192881 22.5,24.5 C22.5,25.8807119 23.6192881,27 25,27 L75,27 C76.3807119,27 77.5,25.8807119 77.5,24.5 C77.5,23.1192881 76.3807119,22 75,22 L62.314325,22 L62.314325,22 Z M54.5085033,18.5 L45.4914967,18.5 C44.6793677,18.5 43.6677785,19.2629127 43.4448153,20.0432839 L42.8857535,22 L57.1142465,22 L56.5551847,20.0432839 C56.3320347,19.2622589 55.3211505,18.5 54.5085033,18.5 Z' })
                )
            );
        }.bind(this));
    },

printNavBar: function printNavBar(selectionState, breadcrumbTitle, path, name) {
        if (0 === selectionState.size) {
            return React.createElement(
                'div',
                { id: 'tatsu-header-navigation' },
                ' Select a Module '
            );
        } else if (selectionState.size > 1) {
            return React.createElement(
                'div',
                { id: 'tatsu-header-navigation' },
                React.createElement(
                    'div',
                    { className: 'tatsu-header-breadcrumb' },
                    ' Multiple Modules Selected '
                ),
                React.createElement(
                    'div',
                    { className: 'tatsu-header-tools' },
                    this.getObserverTools(path, name)
                )
            );
        } else {
            return React.createElement(
                'div',
                { id: 'tatsu-header-navigation' },
                React.createElement(
                    'div',
                    { className: 'tatsu-header-breadcrumb' },
                    breadcrumbTitle.map(function (title) {
                        return React.createElement(
                            'a',
                            { onClick: function onClick() {
                                    store.dispatch(setSelection(title.path, 'single'));
                                }, className: 'tatsu-header-breadcrumb-item' },
                            title.name
                        );
                    })
                ),
                React.createElement(
                    'div',
                    { className: 'tatsu-header-tools' },
                    this.getObserverTools(path, name)
                )
            );
        }
    },

render: function render() {

var selectionState = this.props.selectionState.get('selectionList'),
            pathFromSelectionState = getPathFromSelectionState(this.props.selectionState),
            breadcrumbPath = pathFromSelectionState,
            //selectionState.get( 'path' ),
        currentPath = Immutable.List(),
            breadcrumbTitle = [],
            moduleOptions = this.props.moduleOptions,
            path = selectionState.getIn([0, 'path']),
            name = selectionState.getIn([0, 'name']);

if (selectionState.size === 1) {
            breadcrumbPath.forEach(function (path, index) {
                currentPath = currentPath.push(path);
                var targetElement = getTargetElementFromPath(currentPath),
                    parentElement = getTargetElementFromPath(currentPath.pop()),
                    title = '';
                if (targetElement) {
                    title = targetElement.get('title') || moduleOptions.getIn([targetElement.get('name'), 'title']) || 'Module';
                    if (parentElement) {
                        if ('sub_module' == targetElement.get('type') || 'tatsu_button_group' == parentElement.get('name') || 'tatsu_icon_group' == parentElement.get('name')) {
                            return;
                        }
                    }
                    breadcrumbTitle.push({ name: title, path: currentPath });
                }
            });
        }
        return this.printNavBar(selectionState, breadcrumbTitle, path, name);
    },

componentDidMount: function componentDidMount() {

var selectedModules = this.props.selectionState.get('selectionList');
        0 == selectedModules.size ? null : selectedModules.map(function (curSelection, index) {
            addSelectedStyle(curSelection.get('id'));
        }.bind(this));
    },

componentWillUnmount: function componentWillUnmount() {

var selectedModules = this.props.selectionState.get('selectionList');

0 == selectedModules.size ? null : selectedModules.map(function (curSelection, index) {
            removeSelectedStyle(curSelection.get('id'));
        }.bind(this));
    }
});

module.exports = HeaderBuilderNavBar;

function getTargetElementFromPath(path) {

if (0 < path.size) {
        var currentPathArray = keyPath(path, '', '');
        return store.getState().tatsu_page_content.get('present').getIn(currentPathArray);
    }
    return null;
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 224 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

var HeaderColumn = __webpack_require__(151),
    closeDrawer = __webpack_require__(2).closeDrawer,
    findDOMNode = __webpack_require__(7).findDOMNode,
    routeHandler = __webpack_require__(99),
    setSelection = __webpack_require__(2).setSelection,
    resetSelection = __webpack_require__(2).resetSelection,
    store = __webpack_require__(11),
    checkIfSelected = __webpack_require__(80).checkIfSelected,
    isEqual = __webpack_require__(86),
    isEmpty = __webpack_require__(5),
    openContextMenu = __webpack_require__(2).openContextMenu,
    routeResolve = __webpack_require__(33),
    encodePath = __webpack_require__(43).encodePath,
    getAttsBasedOnTargetDisplay = __webpack_require__(53),
    getModuleStyle = __webpack_require__(96),
    getConcatenatedCSS = __webpack_require__(67),
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    HeaderRow = React.createClass({
    displayName: 'HeaderRow',

propTypes: {
        headerRow: mapChecker,
        path: listChecker,
        // parent : mapChecker,
        moduleOptions: mapChecker,
        pathFromSelectionState: listChecker,
        dropEffect: React.PropTypes.string,
        targetDisplay: React.PropTypes.string
    },

triggerJs: false,

mouseEnterHandler: function mouseEnterHandler(event) {
        var isMultiSelected = Immutable.List.isList(this.props.pathFromSelectionState.get(0)),
            selectionPath = this.props.pathFromSelectionState,
            curPath = this.props.path;
        if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
        if (!(isMultiSelected && selectionPath.contains(curPath) || Immutable.is(curPath, selectionPath))) {
            var rowTitle = this.props.moduleOptions.getIn(['tatsu_header_row', 'title']) || 'Header Row',
                messageData = 'hover_set,' + this.props.headerRow.get('id') + ',' + rowTitle;
            document.getElementById('tatsu-preview').contentWindow.postMessage(messageData, '*');
        }
    },

getInitialState: function getInitialState() {
        return {
            curDraggingCols: []
        };
    },

setCurDraggingCol: function setCurDraggingCol(indexArray) {
        this.setState({
            curDraggingCols: indexArray
        });
    },

resetCurDraggingCol: function resetCurDraggingCol() {
        this.setState({
            curDraggingCols: []
        });
    },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

if (this.props.headerRow.getIn(['atts', 'full_width']) != nextProps.headerRow.getIn(['atts', 'full_width'])) {
            this.triggerJs = true;
        }
    },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
        result = !(Immutable.is(this.props.pathFromSelectionState, nextProps.pathFromSelectionState) && Immutable.is(this.props.path, nextProps.path) && this.props.dropEffect == nextProps.dropEffect && Immutable.is(this.props.headerRow, nextProps.headerRow) && this.props.targetDisplay == nextProps.targetDisplay && isEqual(this.state, nextState));
        return result;
    },

handleRightClick: function handleRightClick(event) {

if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        event.preventDefault();
        event.stopPropagation();
        var currentTop = event.clientY,
            currentLeft = event.clientX + (-1 < document.body.className.indexOf('mce-fullscreen') ? 0.3 * window.innerWidth : 300),
            path = this.props.path,
            name = this.props.headerRow.get('name'),
            id = this.props.headerRow.get('id'),
            clientRect = findDOMNode(this).getBoundingClientRect(),
            title = this.props.headerRow.get('title');
        store.dispatch(openContextMenu(currentTop, currentLeft, path, name, title, id, clientRect));
    },

componentDidUpdate: function componentDidUpdate() {

if (this.triggerJs) {
            this.triggerJs = false;
            var jsTriggerData, jsTriggerJSONData;
            jsTriggerData = {
                type: 'jstrigger',
                moduleName: 'trigger_ready'
            };
            jsTriggerJSONData = JSON.stringify(jsTriggerData);
            document.getElementById('tatsu-preview').contentWindow.postMessage(jsTriggerJSONData, '*');
        }
    },

mouseLeaveHandler: function mouseLeaveHandler() {
        if (-1 < document.body.className.indexOf("preview")) {
            return;
        }
        document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    },

getRowWrapperClass: function getRowWrapperClass(atts, row) {

return rowWrapperClass;
    },

render: function render() {
        var path = this.props.path,
            headerRow = this.props.headerRow,
            moduleOptions = this.props.moduleOptions || Immutable.Map(),
            targetDisplay = this.props.targetDisplay,
            idString = headerRow.get('id'),
            children = headerRow.get('inner'),
            moduleName = headerRow.get('name'),
            attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']),
            atts = getAttsBasedOnTargetDisplay(headerRow.get('atts'), this.props.targetDisplay, attsFromModuleOptions),
            moduleStyles = getModuleStyle(headerRow, this.props.targetDisplay, moduleOptions),
            cssObject = getConcatenatedCSS(moduleStyles),
            pathFromSelectionState = this.props.pathFromSelectionState,
            dropEffect = this.props.dropEffect,
            title = headerRow.get('name'),
            builderMode = this.props.builderMode,
            validPathSize = this.props.builderMode == 'header_builder' ? 1 : 2,
            rowWrapperClass = this.getRowWrapperClass(atts, headerRow),
            customRowClass = 'string' === typeof atts.get('row_class') && '' != atts.get('row_class') ? atts.get('row_class') : '',
            customRowId = 'string' === typeof atts.get('row_id') && '' != atts.get('row_id') ? atts.get('row_id') : null,
            rowClass = !isEmpty(atts.get('sticky_header')) ? ' tatsu-sticky-header' : '';
        rowClass = rowClass + !isEmpty(atts.get('default_visibility')) ? ' default-' + atts.get('default_visibility') : '';
        rowClass = rowClass + !isEmpty(atts.get('sticky_visibility')) ? ' sticky-' + atts.get('sticky_visibility') : '';

return React.createElement(
            'div',
            { className: "tatsu-header be-preview " + rowClass + " be-pb-observer-" + idString, style: jQuery.extend({}, cssObject.style['.tatsu-header'], cssObject.style['root']), onMouseEnter: validPathSize == path.size ? this.mouseEnterHandler : null, onMouseLeave: validPathSize == path.size ? this.mouseLeaveHandler : null, onClick: validPathSize == path.size ? routeHandler.bind(null, path) : null, onContextMenu: validPathSize == path.size ? this.handleRightClick : null },
            React.createElement(
                'div',
                { className: "tatsu-header-row " + customRowClass + " " + rowWrapperClass, style: cssObject.style['.tatsu-header-row'], id: customRowId },
                children.map(function (column, index) {
                    var columnPath = path,
                        widthDraggerPlaceholderPosition = false;
                    columnPath = columnPath.push(children.indexOf(column));
                    if (-1 < this.state.curDraggingCols.indexOf(index)) {
                        widthDraggerPlaceholderPosition = 0 === this.state.curDraggingCols.indexOf(index) ? 'right' : 'left';
                    }
                    return React.createElement(HeaderColumn, { widthDraggerPlaceholderPosition: widthDraggerPlaceholderPosition, builderMode: builderMode, pathFromSelectionState: pathFromSelectionState, dropEffect: dropEffect, key: column.get('id'), targetDisplay: targetDisplay, path: columnPath, setCurDraggingCol: this.setCurDraggingCol, resetCurDraggingCol: this.resetCurDraggingCol, column: column, parent: headerRow, moduleOptions: moduleOptions });
                }.bind(this))
            )
        );
    }

});

module.exports = HeaderRow;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 225 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

var React = __webpack_require__(0);

var AddLink = React.createClass({
    displayName: 'AddLink',

getInitialState: function getInitialState() {
        var newTab = this.props.getCurrentLinkData().target;

if (newTab === '_blank') {
            newTab = true;
        } else {
            newTab = false;
        }

return {
            newTab: newTab,
            styleClass: this.props.currentClass || ' ',
            linkText: this.props.getCurrentLinkData().url || '#'
        };
    },

componentDidUpdate: function componentDidUpdate(prevProps, prevState) {

if (this.props.toolBarState.get('url')) {
            var currentHrefValue = this.refs.linkInput.value,
                actualHrefValue = this.props.getCurrentLinkData().url;
            if (actualHrefValue != currentHrefValue) {
                this.refs.linkInput.value = actualHrefValue;
            }
        }
    },
    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        var newTab = this.props.getCurrentLinkData().target;

if (newTab === '_blank') {
            newTab = true;
        } else {
            newTab = false;
        }
        if (this.props.currentClass !== nextProps.currentClass) {
            this.setState({ newTab: newTab, styleClass: nextProps.currentClass });
        }
    },
    styleHandler: function styleHandler(item) {
        if (item === this.state.styleClass) {
            this.setState({ styleClass: ' ' }, function () {
                this.props.applyClass(this.state.styleClass, 'inlineLink');
            }.bind(this));
        } else {
            this.setState({ styleClass: item }, function () {
                this.props.applyClass(this.state.styleClass, 'inlineLink');
            }.bind(this));
        }
    },
    newTabHandler: function newTabHandler() {
        this.setState({ newTab: !this.state.newTab }, function () {
            this.props.addLink(this.state.linkText, this.state.newTab, this.state.styleClass);
        }.bind(this));
    },
    linkKeyUpHandler: function linkKeyUpHandler(e) {
        if (13 == e.which) {
            this.props.addLink(this.state.linkText, this.state.newTab, this.state.styleClass);
        }
    },
    inputChange: function inputChange(e) {
        this.setState({ linkText: e.target.value });
    },
    render: function render() {

var styleBtns = {
            'tatsu-inline-link-style1': 'Style 1',
            'tatsu-inline-link-style2': 'Style 2',
            'tatsu-inline-link-style3': 'Style 3'
        };
        var btnElements = [];
        var tempNum = 0;
        var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';

for (var btn in styleBtns) {
            tempNum++;
            btnElements.push(React.createElement(
                'div',
                { onClick: this.styleHandler.bind(this, btn), onMouseDown: this.props.handleMD, onMouseUp: this.props.preventDefault, style: { minWidth: '36px', lineHeight: '3', height: '36px', borderRight: tempNum !== 3 ? '1px solid #32373d' : 'none', cursor: 'pointer' } },
                React.createElement(
                    'div',
                    { style: { color: btn === this.state.styleClass ? primaryColor : '#c4c4c4', paddingLeft: '8px', paddingRight: '8px', fontSize: '12px', fontFamily: 'Arial, sans-serif', fontWeight: 'bold', letterSpacing: '1px', textTransform: 'uppercase' } },
                    styleBtns[btn]
                )
            ));
        }

return React.createElement(
            'div',
            { className: 'tatsu-inline-inner-wrap tatsu-linkinput-wrap' },
            React.createElement(
                'div',
                { style: { display: 'flex', justifyContent: 'center' } },
                btnElements,
                React.createElement(
                    'div',
                    { className: 'tatsu-inline-link-close-button', style: { width: '20px', height: '20px', padding: '0px', position: 'absolute', top: '-10px', right: '-10px', background: primaryColor, borderRadius: '50%' }, tooltip: 'Close', onMouseDown: this.props.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'url') },
                    React.createElement(
                        'span',
                        { color: '#c4c4c4', style: { position: 'absolute', top: 2, left: 2, fontSize: 14, color: '#fff' } },
                        React.createElement(
                            'svg',
                            { fill: '#fff', style: { height: 16, width: 16 }, className: 'tatsu-svg-icon', viewBox: '0 0 20 20' },
                            React.createElement('path', { d: 'M15.898,4.045c-0.271-0.272-0.713-0.272-0.986,0l-4.71,4.711L5.493,4.045c-0.272-0.272-0.714-0.272-0.986,0s-0.272,0.714,0,0.986l4.709,4.711l-4.71,4.711c-0.272,0.271-0.272,0.713,0,0.986c0.136,0.136,0.314,0.203,0.492,0.203c0.179,0,0.357-0.067,0.493-0.203l4.711-4.711l4.71,4.711c0.137,0.136,0.314,0.203,0.494,0.203c0.178,0,0.355-0.067,0.492-0.203c0.273-0.273,0.273-0.715,0-0.986l-4.711-4.711l4.711-4.711C16.172,4.759,16.172,4.317,15.898,4.045z' })
                        )
                    )
                )
            ),
            React.createElement(
                'div',
                { style: { display: 'flex', alignItems: 'center', marginBottom: 5 } },
                React.createElement('input', { onBlur: this.props.handleBlur, ref: 'linkInput', id: 'tatsu-inline-link-area', type: 'text', onMouseDown: this.props.handleF.bind(null, true), onChange: this.inputChange, onKeyUp: this.linkKeyUpHandler, value: this.state.linkText }),
                React.createElement(
                    'div',
                    { onClick: this.newTabHandler.bind(this), onMouseDown: this.props.handleMD, onMouseUp: this.props.preventDefault, style: { minWidth: '20px', lineHeight: '1', height: '24px', fill: this.state.newTab ? primaryColor : '#c4c4c4' } },
                    React.createElement(
                        'svg',
                        { viewBox: '0 0 128 128' },
                        React.createElement('path', { d: 'M109.939,128H1.567V19.627h57.282v9.289H10.856v89.794h89.794v-51.09h9.289V128z M71.948,61.052 l-6.568-6.568l43.566-43.567l-30.362,2.759l-0.841-9.25L126.433,0l-4.427,48.686l-9.253-0.841l2.761-30.36L71.948,61.052z' })
                    )
                )
            )
        );
    }
});

module.exports = AddLink;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 226 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery, React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _menu = __webpack_require__(91);

var _menu2 = _interopRequireDefault(_menu);

__webpack_require__(92);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Divider = _menu2.default.Divider;

exports.default = function (props) {

var children = props.children,
        eventKey = props.eventKey,
        propsWithoutChildren = jQuery.extend({}, props);

delete propsWithoutChildren.children;
    delete propsWithoutChildren.eventKey;

children = React.Children.map(children, function (child, index) {
        return React.cloneElement(child, jQuery.extend({}, propsWithoutChildren, {
            key: 'key' + props.ind + index,
            eventKey: props.ind + index
        }));
    });
    if (!props.dividerNotAllowed) {
        children = React.Children.toArray(children);
        children.push(React.createElement(Divider, props));
    }
    return React.createElement(
        'div',
        null,
        children
    );
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4), __webpack_require__(0)))

/***/ }),
/* 227 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery, React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _menu = __webpack_require__(91);

var _menu2 = _interopRequireDefault(_menu);

__webpack_require__(92);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Item = _menu2.default.Item;

exports.default = function (props) {
    props = jQuery.extend({}, props, { disabled: props.hasOwnProperty('disabled') ? props.disabled : null });
    return React.createElement(
        Item,
        props,
        props.children
    );
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4), __webpack_require__(0)))

/***/ }),
/* 228 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var Observer = __webpack_require__(153),
    deleteModule = __webpack_require__(2).deleteModule,
    duplicate = __webpack_require__(2).duplicate,
    routeResolve = __webpack_require__(33),
    browserHistory = __webpack_require__(40).browserHistory,
    encodePath = __webpack_require__(43).encodePath,
    getPathFromSelectionState = __webpack_require__(97),
    store = __webpack_require__(11),
    Observers = React.createClass({
    displayName: 'Observers',

shouldComponentUpdate: function shouldComponentUpdate(nextProps) {

render: function render() {

var selectionState = this.props.selectionState.get('selectionList'),
            dropEffect = this.props.dropEffect,
            moduleOptions = this.props.moduleOptions,
            builderMode = this.props.builderMode,
            pathFromSelectionState = getPathFromSelectionState(this.props.selectionState),
            hide = this.props.selectionState.get('hide');
        return 0 == selectionState.size ? null : React.createElement(
            'div',
            null,
            selectionState.map(function (curSelection, index) {

return React.createElement(Observer, {
                    triggerTool: this.triggerTool,
                    availableTools: this.getAvailableTools(curSelection),
                    moduleOptions: moduleOptions,
                    key: curSelection.get('id'),
                    top: curSelection.get('top'),
                    left: curSelection.get('left'),
                    hide: hide,
                    path: curSelection.get('path'),
                    id: curSelection.get('id'),
                    name: curSelection.get('name'),
                    title: curSelection.get('title'),
                    builderType: curSelection.get('builderType'),
                    dragHandle: curSelection.get('dragHandle'),
                    pathFromSelectionState: pathFromSelectionState,
                    dropEffect: dropEffect,
                    builderMode: builderMode
                });
            }.bind(this))
        );
    }

});
module.exports = Observers;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 229 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _reactContentLoader = __webpack_require__(1215);

var _reactContentLoader2 = _interopRequireDefault(_reactContentLoader);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

__webpack_require__(552);

var Post = function Post(props) {
  return React.createElement(
    "div",
    { className: "frame-loader-container" },
    React.createElement(
      "div",
      { className: "frame-loader-row-wrap" },
      React.createElement(
        "div",
        { className: "frame-loader-row" },
        React.createElement(
          "div",
          { className: "frame-loader-col" },
          React.createElement(
            _reactContentLoader2.default,
            _extends({
              speed: 2,
              height: 140,
              primaryColor: "#f3f3f3",
              secondaryColor: "#ecebeb"
            }, props),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "0", width: "400", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "20", width: "350", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "40", width: "300", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "70", width: "400", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "90", width: "400", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "110", width: "400", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "130", width: "400", height: "10" })
          )
        ),
        React.createElement(
          "div",
          { className: "frame-loader-col" },
          React.createElement(_reactContentLoader2.default, _extends({
            speed: 2,
            height: 300,
            primaryColor: "#f3f3f3",
            secondaryColor: "#ecebeb"
          }, props))
        )
      )
    ),
    React.createElement(
      "div",
      { className: "frame-loader-row-wrap" },
      React.createElement(
        "div",
        { className: "frame-loader-row" },
        React.createElement(
          "div",
          { className: "frame-loader-col" },
          React.createElement(_reactContentLoader2.default, _extends({
            speed: 2,
            height: 300,
            primaryColor: "#f3f3f3",
            secondaryColor: "#ecebeb"
          }, props))
        ),
        React.createElement(
          "div",
          { className: "frame-loader-col" },
          React.createElement(
            _reactContentLoader2.default,
            _extends({
              speed: 1,
              height: 150,
              primaryColor: "#f3f3f3",
              secondaryColor: "#ecebeb"
            }, props),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "0", width: "400", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "20", width: "350", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "40", width: "300", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "70", width: "400", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "90", width: "400", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "110", width: "400", height: "10" }),
            React.createElement("rect", { rx: "5", ry: "5", x: "0", y: "130", width: "400", height: "10" })
          )
        )
      )
    )
  );
};

exports.default = Post;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 230 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

var Observers = __webpack_require__(228),
    Frames = __webpack_require__(222),
    TopToolBar = __webpack_require__(235).default,
    ContextMenu = __webpack_require__(218).default,
    InlineEditorToolbar = __webpack_require__(234),
    routeResolve = __webpack_require__(33),
    encodePath = __webpack_require__(43).encodePath,
    getScrollDistance = __webpack_require__(369),
    findDOMNode = ReactDOM.findDOMNode,
    getPathFromSelectionState = __webpack_require__(97),
    setSelection = __webpack_require__(2).setSelection,
    changeSelectionPosition = __webpack_require__(2).changeSelectionPosition,
    scrollToSelectedNode = __webpack_require__(241),
    Observer = __webpack_require__(153),
    PostsLoader = __webpack_require__(229).default,
    CustomDragLayer = __webpack_require__(219),
    store = __webpack_require__(11),
    DropPlaceholder = __webpack_require__(220),
    mapChecker = __webpack_require__(16).mapChecker,
    Sections = __webpack_require__(232);
var RightPanel = React.createClass({
  displayName: 'RightPanel',

propTypes: {
    state: React.PropTypes.object.isRequired
  },

render: function render() {

var state = this.props.state,
        inlineController = state.inlineController,
        moduleOptions = state.moduleOptions || Immutable.Map(),
        targetDisplay = state.targetDisplay.get('targetDisplay'),
        pageContent = state.tatsu_page_content.get('present'),
        lastSavedState = state.lastSavedState,
        contextMenuController = state.contextMenuController,
        selectionState = state.selectionController,
        pathFromSelectionState = getPathFromSelectionState(selectionState),
        dragMonitor = state.dragMonitor,
        copyAtts = state.copyAtts,
        messageBox = state.messageBox,
        builderMode = state.builderMode,
        InitialComponentName = builderMode === 'header_builder' ? 'headerRows' : 'sections',
        InitialComponent = __webpack_require__(556)("./" + InitialComponentName);

return React.createElement(
      'div',
      { id: 'tatsu-rightpanel-wrapper' },
      React.createElement(TopToolBar, { messageBox: messageBox, currentState: pageContent.get('inner'), lastSavedState: lastSavedState, pageContent: pageContent, builderMode: this.props.state.builderMode, modulePath: pathFromSelectionState, pathFromRoute: this.props.pathFromRoute }),
      !state.initialState.get('frameLoaded') && React.createElement(PostsLoader, null),
      React.createElement(
        Frames,
        { frameLoaded: state.initialState.get('frameLoaded'), targetDisplay: targetDisplay, builderMode: builderMode, isDragging: dragMonitor.get('isDragging'), dragType: dragMonitor.get('type'), selectionState: selectionState, moduleOptions: moduleOptions },
        React.createElement(InitialComponent, { builderMode: builderMode, pageContent: pageContent, pathFromSelectionState: pathFromSelectionState, moduleOptions: moduleOptions, targetDisplay: targetDisplay, dropEffect: dragMonitor.get('dropEffect') }),
        React.createElement(CustomDragLayer, { moduleOptions: moduleOptions, dropEffect: dragMonitor.get('dropEffect'), selectionState: selectionState }),
        React.createElement(InlineEditorToolbar, { toolBarState: inlineController, isAbsolute: true }),
        React.createElement(ContextMenu, { builderMode: builderMode, copyAtts: copyAtts, selectionController: selectionState, contextMenuState: contextMenuController, moduleOptions: moduleOptions }),
        !(builderMode === 'header_builder' && targetDisplay === 'mobile') && React.createElement(Observers, { builderMode: builderMode, dropEffect: dragMonitor.get('dropEffect'), selectionState: selectionState, isAbsolute: true, moduleOptions: moduleOptions }),
        React.createElement(DropPlaceholder, { isAbsolute: true, dragMonitor: dragMonitor })
      )
    );
  },

componentDidUpdate: function componentDidUpdate(prevProps) {
    // Modify TATSU Frame's scroll postion and Module Title when Target Display has changed
    if (prevProps.state.targetDisplay.get('targetDisplay') !== this.props.state.targetDisplay.get('targetDisplay')) {
      var currentDocument = document.getElementById('tatsu-preview').contentDocument,
          selectedModuleId = this.props.state.selectionController.getIn(['selectionList', 0, 'id']),
          currentNode,
          nodeTop,
          nodeLeft;
      if (null != selectedModuleId) {
        currentNode = currentDocument.getElementsByClassName('be-pb-observer-' + selectedModuleId)[0], nodeTop = getScrollDistance(currentNode) - 65, nodeLeft = currentNode.getBoundingClientRect().left;
        jQuery(currentDocument).find('html').scrollTop(nodeTop);

setTimeout(function () {
          store.dispatch(changeSelectionPosition(currentNode, getScrollDistance(currentNode), currentNode.getBoundingClientRect().left));
        }, 200);
      }
    }
  }

});

module.exports = RightPanel;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 231 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

var Row = __webpack_require__(156),
    routeHandler = __webpack_require__(99),
    mapChecker = __webpack_require__(16).mapChecker,
    fitVideoToContainer = __webpack_require__(236),
    getAttFromDisplay = __webpack_require__(123),
    listChecker = __webpack_require__(16).listChecker,
    editAtt = __webpack_require__(2).editAtt,
    setSelection = __webpack_require__(2).setSelection,
    getValAndUnit = __webpack_require__(237),
    isEmpty = __webpack_require__(5),
    findDOMNode = __webpack_require__(7).findDOMNode,
    store = __webpack_require__(11),
    cssAnimateHelper = __webpack_require__(120),
    CssNewAnimate = __webpack_require__(124),
    getAttsBasedOnDisplay = __webpack_require__(53),
    getModuleStyle = __webpack_require__(96),
    getConcatenatedCSS = __webpack_require__(67),
    openContextMenu = __webpack_require__(2).openContextMenu;

var Section = React.createClass({
  displayName: 'Section',

triggerJs: false,
  prevCurPosition: null,
  animateObj: null,
  boundaries: {},
  timeout: null,
  triggerSectionJs: false,
  propTypes: {
    path: listChecker,
    pathFromSelectionState: listChecker,
    section: mapChecker,
    moduleOptions: mapChecker,
    targetDisplay: React.PropTypes.string,
    dropEffect: React.PropTypes.string
  },

componentWillMount: function componentWillMount() {

this.animateObj = new CssNewAnimate(this.props.section, false);
  },

getInitialState: function getInitialState() {
    return {
      activeBoxModelDragger: false,
      visibleBoxModelDraggers: Immutable.List()
    };
  },

handleRightClick: function handleRightClick(event) {

if (-1 < document.body.className.indexOf("preview")) {
      return;
    }
    event.preventDefault();
    var currentTop = event.clientY,
        currentLeft = event.clientX + (-1 < document.body.className.indexOf('mce-fullscreen') ? 0.3 * window.innerWidth : 300),
        path = this.props.path,
        name = this.props.section.get('name'),
        id = this.props.section.get('id'),
        clientRect = findDOMNode(this).getBoundingClientRect(),
        title = this.props.section.get('title');
    store.dispatch(openContextMenu(currentTop, currentLeft, path, name, title, id, clientRect));
  },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

var currentAtts = this.props.section.get('atts'),
        newAtts = nextProps.section.get('atts');
    if ('tatsu-parallax' != currentAtts.get('bg_animation') && 'tatsu-parallax' == newAtts.get('bg_animation') || currentAtts.get('section_height_type') != newAtts.get('section_height_type')) {
      this.triggerSectionJs = true;
    }
    if (currentAtts.get('offset_value') != newAtts.get('offset_value') || currentAtts.get('padding') != newAtts.get('padding') || currentAtts.get('margin') != newAtts.get('margin')) {
      this.triggerJs = true;
    }
  },

componentDidMount: function componentDidMount() {

componentDidUpdate: function componentDidUpdate(prevProps) {

cssAnimateHelper(this);
    this.animateObj.triggerAnimation(this.props.section);
    var atts = this.props.section.get('atts'),
        prevAtts = prevProps.section.get('atts'),
        data,
        jsonData;
    if ('' != this.props.section.getIn(['atts', 'bg_video_mp4_src']) || '' != this.props.section.getIn(['atts', 'bg_video_ogg_src']) || '' != this.props.section.getIn(['atts', 'bg_video_webm_src']) || this.props.section.getIn(['atts', 'section_height_type']) === 'full_screen') {
      var bgVideoWrap = jQuery(this.refs.videoRef);
      fitVideoToContainer(bgVideoWrap);
    }
    if (this.triggerSectionJs) {
      this.triggerSectionJs = false;
      data = {
        type: 'jstrigger',
        moduleName: 'tatsu_section',
        shouldUpdate: true
      };
      jsonData = JSON.stringify(data);
      document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
    }
    if (this.triggerJs) {
      data = {
        type: 'jstrigger',
        moduleName: 'trigger_ready'
      };
      jsonData = JSON.stringify(data);
      document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
      this.triggerJs = false;
    }
  },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
    result = !(Immutable.is(this.props.pathFromSelectionState, nextProps.pathFromSelectionState) && Immutable.is(this.props.section, nextProps.section) && Immutable.is(this.props.path, nextProps.path) && this.props.targetDisplay == nextProps.targetDisplay && this.state.activeBoxModelDragger == nextState.activeBoxModelDragger && Immutable.is(this.state.visibleBoxModelDraggers, nextState.visibleBoxModelDraggers) && this.props.dropEffect == nextProps.dropEffect);
    return result;
  },

updateBoundaries: function updateBoundaries() {
    var curEle = findDOMNode(this),
        tatsuPreview = document.getElementById('tatsu-preview');
    if (null != curEle && null != tatsuPreview) {
      this.boundaries.top = (tatsuPreview.contentWindow.pageYOffset || tatsuPreview.contentDocument.documentElement.scrollTop) + curEle.getBoundingClientRect().top;
      this.boundaries.bottom = this.boundaries.top + curEle.offsetHeight;
    }
  },

mouseEnterHandler: function mouseEnterHandler(event) {

mouseLeaveHandler: function mouseLeaveHandler(event) {

if (-1 < document.body.className.indexOf("preview")) {
      return;
    }
    clearTimeout(this.timeout);
    this.timeout = null;
    if (false === this.state.activeBoxModelDragger && 0 < this.state.visibleBoxModelDraggers.size) {
      this.setState({
        visibleBoxModelDraggers: Immutable.List()
      });
    }
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
  },

getBorder: function getBorder(position) {
    var positionIndexMap = ['top', 'right', 'bottom', 'left'],
        curBorder = this.props.section.getIn(['atts', 'border']),
        curBorderArray,
        curBorderColor = this.props.section.getIn(['atts', 'border_color']);
    if (isEmpty(curBorderColor) || isEmpty(position)) {
      return 0;
    }
    curBorderArray = 'string' == typeof curBorder ? curBorder.trim().split(/\s+/) : [];
    return !isNaN(parseInt(curBorderArray[positionIndexMap.indexOf(position)])) ? parseInt(curBorderArray[positionIndexMap.indexOf(position)]) : 0;
  },

getPadding: function getPadding(position, unit) {
    var curTargetDisplay = 'string' == typeof this.props.targetDisplay ? this.props.targetDisplay.charAt(0) : '',
        positionIndexMap = ['top', 'right', 'bottom', 'left'],
        curPadding = getAttFromDisplay(this.props.section.getIn(['atts', 'padding']), curTargetDisplay),
        curPaddingArray;
    if (isEmpty(position)) {
      return 0;
    }
    curPaddingArray = 'string' == typeof curPadding ? curPadding.trim().split(/\s+/) : [];
    if (isEmpty(unit)) {
      return !isNaN(parseInt(curPaddingArray[positionIndexMap.indexOf(position)])) ? parseInt(curPaddingArray[positionIndexMap.indexOf(position)]) : 0;
    } else {
      return !isEmpty(curPaddingArray[positionIndexMap.indexOf(position)]) ? curPaddingArray[positionIndexMap.indexOf(position)] : '0px';
    }
  },

incrementPadding: function incrementPadding(val) {
    var position = this.state.activeBoxModelDragger,
        curTargetDisplay = 'string' == typeof this.props.targetDisplay ? this.props.targetDisplay.charAt(0) : '',
        positionIndexMap = ['top', 'right', 'bottom', 'left'],
        curPadding = getAttFromDisplay(this.props.section.getIn(['atts', 'padding']), curTargetDisplay),
        curPaddingArray = 'string' == typeof curPadding ? curPadding.trim().split(/\s+/) : [];
    if (isEmpty(position) || isNaN(parseInt(curPaddingArray[positionIndexMap.indexOf(position)]))) {
      return curPadding;
    }
    return curPaddingArray.reduce(function (acc, curVal, index) {
      var valUnitObj;
      if ('top' === position && 0 === index || 'bottom' === position && 2 === index) {
        valUnitObj = getValAndUnit(curVal);
        curVal = parseInt(valUnitObj.value) + val + valUnitObj.unit;
      }
      return 0 === index ? curVal : acc + ' ' + curVal;
    }, '');
  },

decrementPadding: function decrementPadding(val) {
    var position = this.state.activeBoxModelDragger,
        curTargetDisplay = 'string' == typeof this.props.targetDisplay ? this.props.targetDisplay.charAt(0) : '',
        positionIndexMap = ['top', 'right', 'bottom', 'left'],
        curPadding = getAttFromDisplay(this.props.section.getIn(['atts', 'padding']), curTargetDisplay),
        curPaddingArray = 'string' == typeof curPadding ? curPadding.trim().split(/\s+/) : [];
    if (isEmpty(position) || isNaN(parseInt(curPaddingArray[positionIndexMap.indexOf(position)]))) {
      return curPadding;
    }
    return curPaddingArray.reduce(function (acc, curVal, index) {
      var valUnitObj;
      if ('top' === position && 0 === index || 'bottom' === position && 2 === index) {
        valUnitObj = getValAndUnit(curVal);
        curVal = 0 <= parseInt(valUnitObj.value) - val ? parseInt(valUnitObj.value) - val + valUnitObj.unit : 0 + valUnitObj.unit;
      }
      return 0 === index ? curVal : acc + ' ' + curVal;
    }, '');
  },

showBoxDragger: function showBoxDragger(e) {
    var curPos = e.pageY,
        borderTop = this.getBorder('top'),
        borderBottom = this.getBorder('bottom'),
        paddingTop = this.getPadding('top') || 15,
        curVisibleBoxModelDraggers = this.state.visibleBoxModelDraggers,
        curActiveBoxModelDragger = this.state.activeBoxModelDragger,
        newVisibleBoxModelDraggers,
        paddingBottom = this.getPadding('bottom') || 15;
    if (!curActiveBoxModelDragger) {
      if (this.boundaries.top + borderTop < curPos && this.boundaries.top + borderTop + paddingTop > curPos) {
        //show top padding dragger
        if (-1 == curVisibleBoxModelDraggers.indexOf('top')) {
          if (null === this.timeout) {
            this.timeout = setTimeout(function () {
              newVisibleBoxModelDraggers = curVisibleBoxModelDraggers.push('top');
              this.setState({ visibleBoxModelDraggers: newVisibleBoxModelDraggers });
            }.bind(this), 200);
          }
        }
      } else if (curPos < this.boundaries.bottom - borderBottom && this.boundaries.bottom - paddingBottom - borderBottom < curPos) {
        if (-1 == this.state.visibleBoxModelDraggers.indexOf('bottom')) {
          if (null === this.timeout) {
            this.timeout = setTimeout(function () {
              newVisibleBoxModelDraggers = curVisibleBoxModelDraggers.push('bottom');
              this.setState({ visibleBoxModelDraggers: newVisibleBoxModelDraggers });
            }.bind(this), 200);
          }
        }
      } else {
        if (0 != curVisibleBoxModelDraggers.length) {
          clearTimeout(this.timeout);
          this.timeout = null;
          this.setState({ visibleBoxModelDraggers: Immutable.List() });
        }
      }
    }
  },

handleBoxDragger: function handleBoxDragger(e) {
    if (-1 < document.body.className.indexOf("preview")) {
      return;
    }
    var curPos = e.pageY,
        direction,
        curActiveBoxModelDragger = this.state.activeBoxModelDragger;
    if (!isEmpty(curActiveBoxModelDragger)) {
      direction = curPos > this.prevCurPosition ? 'down' : 'up';
      if ('down' === direction) {
        store.dispatch(editAtt(this.props.path, 'padding', this.incrementPadding(curPos - this.prevCurPosition), this.props.moduleOptions, 1, true, this.props.targetDisplay));
      } else {
        store.dispatch(editAtt(this.props.path, 'padding', this.decrementPadding(this.prevCurPosition - curPos), this.props.moduleOptions, 1, true, this.props.targetDisplay));
      }
      this.prevCurPosition = curPos;
    }
  },

getSectionClass: function getSectionClass(atts) {

var sectionClass = '',
        deviceVisibility = atts.get('hide_in'),
        visibilityArray;

if (!isEmpty(deviceVisibility)) {
      visibilityArray = deviceVisibility.split(',');
      visibilityArray.forEach(function (device, index) {
        sectionClass = sectionClass + 'tatsu-hide-' + device + ' ';
      });
    }
    if ('string' === typeof atts.get('section_class')) {

sectionClass = sectionClass + atts.get('section_class') + ' ';
    }

if (!isEmpty(atts.get('overflow'))) {
      sectionClass = sectionClass + 'tatsu-prevent-overflow ';
    }

if (!isEmpty(atts.get('bg_animation')) && 'tatsu-parallax' === atts.get('bg_animation')) {

sectionClass = sectionClass + atts.get('bg_animation') + ' ';
    }
    if (atts.get('offset_value') !== '0px') {

sectionClass = sectionClass + 'tatsu-section-offset ';
    }
    if ('' != atts.get('bg_video_mp4_src') || '' != atts.get('bg_video_ogg_src') || '' != atts.get('bg_video_webm_src')) {

sectionClass = sectionClass + 'tatsu-video-section ';
    }
    if (!isEmpty(atts.get('bg_overlay'))) {

sectionClass = sectionClass + 'tatsu-bg-overlay ';
    }
    if (this.props.section.getIn(['atts', 'section_height_type']) === 'full_screen') {

sectionClass = sectionClass + 'tatsu-fullscreen ';
    }
    if (this.props.section.getIn(['atts', 'section_height_type']) === 'custom_height') {
      sectionClass = sectionClass + 'tatsu-section-custom-height ';
    }

return sectionClass;
  },

getVideoMarkup: function getVideoMarkup(atts) {

getOverlayMarkup: function getOverlayMarkup(atts, cssObject) {

var finalMarkUp = React.createElement('div', { className: 'tatsu-overlay', style: cssObject['.tatsu-section-overlay'] });

return finalMarkUp;
  },

renderRows: function renderRows(children, path, section, moduleOptions) {

return children.map(function (row) {

var rowPath = path;
      rowPath = rowPath.push(children.indexOf(row));
      return React.createElement(Row, { pathFromSelectionState: this.props.pathFromSelectionState, dropEffect: this.props.dropEffect, key: row.get('id'), targetDisplay: this.props.targetDisplay, isDragging: false, row: row, path: rowPath, parent: section, moduleOptions: moduleOptions });
    }.bind(this));
  },

offsetHelper: function offsetHelper(atts, children, path, section, moduleOptions, cssObject) {

if (atts.get('offset_value') !== '0px') {
      return React.createElement(
        'div',
        { className: 'tatsu-section-offset-wrap', style: cssObject['.tatsu-section-offset-wrap'] },
        this.renderRows(children, path, section, moduleOptions)
      );
    } else {
      return this.renderRows(children, path, section, moduleOptions);
    }
  },

getParallaxMarkup: function getParallaxMarkup(atts, cssObject) {

return React.createElement(
      'div',
      { className: 'tatsu-parallax-element-wrap' },
      React.createElement('div', { className: 'tatsu-parallax-element', style: cssObject['.tatsu-parallax-element'] })
    );
  },

getTopShapeDivider: function getTopShapeDivider(atts, cssObject) {
    var topDivider = atts.get('top_divider'),
        topDividerClasses = [];
    if (tatsuConfig && !isEmpty(tatsuConfig.shape_dividers) && !isEmpty(tatsuConfig.shape_dividers.top) && !isEmpty(topDivider) && 'none' != topDivider) {
      topDividerClasses.push('tatsu-shape-divider', 'tatsu-top-divider');
      if (!isEmpty(atts.get('invert_top_divider'))) {
        topDividerClasses.push('tatsu-invert-divider');
      }
      if (!isEmpty(atts.get('flip_top_divider'))) {
        topDividerClasses.push('tatsu-flip-divider');
      }
      if (!isEmpty(atts.get('top_divider_position')) && 'over' == atts.get('top_divider_position')) {
        topDividerClasses.push('tatsu-shape-over');
      }
      topDividerClasses = topDividerClasses.join(' ');
      return React.createElement('div', { className: topDividerClasses, style: cssObject['> .tatsu-top-divider'], dangerouslySetInnerHTML: { __html: tatsuConfig.shape_dividers.top[topDivider] } });
    }
    return null;
  },

getBottomShapeDivider: function getBottomShapeDivider(atts, cssObject) {
    var bottomDivider = atts.get('bottom_divider'),
        bottomDividerClasses = [];
    if (tatsuConfig && !isEmpty(tatsuConfig.shape_dividers) && !isEmpty(tatsuConfig.shape_dividers.bottom) && !isEmpty(bottomDivider) && 'none' != bottomDivider) {
      bottomDividerClasses.push('tatsu-shape-divider', 'tatsu-bottom-divider');
      if (!isEmpty(atts.get('invert_bottom_divider'))) {
        bottomDividerClasses.push('tatsu-invert-divider');
      }
      if (!isEmpty(atts.get('flip_bottom_divider'))) {
        bottomDividerClasses.push('tatsu-flip-divider');
      }
      if (!isEmpty(atts.get('bottom_divider_position')) && 'over' == atts.get('bottom_divider_position')) {
        bottomDividerClasses.push('tatsu-shape-over');
      }
      bottomDividerClasses = bottomDividerClasses.join(' ');
      return React.createElement('div', { className: bottomDividerClasses, style: cssObject['> .tatsu-bottom-divider'], dangerouslySetInnerHTML: { __html: tatsuConfig.shape_dividers.bottom[bottomDivider] } });
    }
    return null;
  },

setActiveBoxDragger: function setActiveBoxDragger(position, e) {
    if (0 === e.button) {
      e.stopPropagation();
      var iframe = document.getElementById('tatsu-preview');
      if (null != iframe) {
        this.prevCurPosition = e.pageY;
        iframe.contentDocument.body.classList.add('tatsu-prev-pointer-events');
        iframe.contentWindow.addEventListener('mouseup', this.resetActiveBoxDragger);
        iframe.contentWindow.addEventListener('mousemove', this.handleBoxDragger);
        iframe.contentWindow.postMessage('hover_reset', '*');
        iframe.contentWindow.postMessage('hide_add_tools', '*');
      }
      this.setState({
        activeBoxModelDragger: position
      });
      store.dispatch(setSelection(this.props.path, 'single'));
    }
  },

resetActiveBoxDragger: function resetActiveBoxDragger(e) {
    var iframe = document.getElementById('tatsu-preview'),
        mousePos = e.pageY,
        curActiveBoxModelDragger = this.state.activeBoxModelDragger,
        shouldResetVisibleBoxModelDraggers = false,
        curVisibleBoxModelDraggers = this.state.visibleBoxModelDraggers;
    if (null != iframe) {
      iframe.contentDocument.body.classList.remove('tatsu-prev-pointer-events');
      this.prevCurPosition = -1;
      iframe.contentWindow.removeEventListener('mouseup', this.resetActiveBoxDragger);
      iframe.contentWindow.removeEventListener('mousemove', this.handleBoxDragger);
    }
    this.updateBoundaries();
    if ('top' === curActiveBoxModelDragger) {
      shouldResetVisibleBoxModelDraggers = mousePos < this.boundaries.top;
    } else {
      shouldResetVisibleBoxModelDraggers = mousePos < this.boundaries.bottom - this.getPadding('bottom');
    }
    this.setState({
      activeBoxModelDragger: false,
      visibleBoxModelDraggers: shouldResetVisibleBoxModelDraggers ? Immutable.List() : curVisibleBoxModelDraggers
    });
  },

getBackgroundMarkup: function getBackgroundMarkup(atts, cssObject) {
    var wrapperClasses = ['tatsu-section-background-wrap'],
        bgClasses = ['tatsu-section-background'];
    if (!isEmpty(atts.get('bg_animation')) && 'tatsu-parallax' === atts.get('bg_animation')) {
      wrapperClasses.push('tatsu-parallax-element-wrap');
    }
    if (!isEmpty(atts.get('bg_animation')) && 'tatsu-parallax' !== atts.get('bg_animation')) {
      bgClasses.push(atts.get('bg_animation'));
    }

return React.createElement(
      'div',
      { className: wrapperClasses.join(' ') },
      React.createElement('div', { className: bgClasses.join(' '), style: cssObject['.tatsu-section-background'] })
    );
  },

getLayers: function getLayers(atts, children, path, section, moduleOptions, cssObject) {
    var sectionPadStyle = cssObject['.tatsu-section-pad'];

var primaryBG = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff33' : '#1b86f133';
    return [React.createElement(
      'div',
      { className: 'tatsu-section-pad tatsu-clearfix', style: sectionPadStyle, 'data-padding-top': 'string' === atts.get('padding') ? atts.get('padding').split(' ')[0] : null },
      -1 == document.body.className.indexOf("preview") && -1 != this.state.visibleBoxModelDraggers.indexOf('top') ? React.createElement(
        'div',
        { onMouseDown: this.setActiveBoxDragger.bind(this, 'top'), style: jQuery.extend({}, { height: 15 < this.getPadding('top') ? this.getPadding('top', true) : '15px' }, { background: primaryBG }), className: 'tatsu-section-padding-dragger tatsu-section-padding-dragger-top' },
        this.getPadding('top', true)
      ) : null,
      React.createElement(
        'div',
        { className: 'tatsu-section-pad-inner' },
        this.offsetHelper(atts, children, path, section, moduleOptions, cssObject)
      ),
      -1 == document.body.className.indexOf("preview") && -1 != this.state.visibleBoxModelDraggers.indexOf('bottom') ? React.createElement(
        'div',
        { onMouseDown: this.setActiveBoxDragger.bind(this, 'bottom'), style: jQuery.extend({}, { height: 15 < this.getPadding('bottom') ? this.getPadding('bottom', true) : '15px' }, { background: primaryBG }), className: 'tatsu-section-padding-dragger tatsu-section-padding-dragger-bottom' },
        this.getPadding('bottom', true)
      ) : null
    ), this.getBackgroundMarkup(atts, cssObject), !isEmpty(atts.get('bg_video_mp4_src')) || !isEmpty(atts.get('bg_video_ogg_src')) || !isEmpty(atts.get('bg_video_webm_src')) ? this.getVideoMarkup(atts) : null, !isEmpty(atts.get('be_overlay')) || atts.get('overlay_blend_mode') !== 'none' ? this.getOverlayMarkup(atts, cssObject) : null];
  },

renderHelper: function renderHelper(atts, cssObject, sectionClass, children, path, idString, section, moduleOptions, gradientClass) {

var sectionId = atts.get('section_id'),
        padDraggerPossible = this.props.section.getIn(['atts', 'section_height_type']) === 'auto' && (isEmpty(atts.get('offset_value')) || atts.get('offset_value') === '0px'),
        sectionTitle = atts.get('section_title'),
        pathString = path.toArray().toString().replace(/,/g, '-'),
        isFullScreen = this.props.section.getIn(['atts', 'section_height_type']) === 'full_screen',
        sectionStyle = jQuery.extend({}, cssObject['.tatsu-section'], cssObject['root']),
        gradientBorder = gradientClass['.tatsu-section'];
    return React.createElement(
      'div',
      { 'data-path': pathString, onContextMenu: this.handleRightClick, className: "be-preview tatsu-section-add-tool tatsu-section-preview be-pb-observer-" + idString, onMouseEnter: this.mouseEnterHandler, onMouseLeave: this.mouseLeaveHandler, onClick: routeHandler.bind(null, path), onMouseMove: padDraggerPossible ? this.showBoxDragger : null },
      React.createElement(
        'div',
        { className: "tatsu-section clearfix " + sectionClass + (isFullScreen ? ' ' + gradientBorder : ''), id: 'string' === typeof sectionId && '' != sectionId ? sectionId : null, 'data-title': 'string' === typeof sectionTitle && '' != sectionTitle ? sectionTitle : null, style: sectionStyle },
        [this.getTopShapeDivider(atts, cssObject), isFullScreen ? React.createElement(
          'div',
          { className: 'tatsu-fullscreen-wrap', style: cssObject['.tatsu-fullscreen-wrap'] },
          this.getLayers(atts, children, path, section, moduleOptions, cssObject)
        ) : this.props.section.getIn(['atts', 'section_height_type']) === 'custom_height' ? React.createElement(
          'div',
          { className: 'tatsu-custom-height-wrap', style: cssObject['.tatsu-custom-height-wrap'] },
          this.getLayers(atts, children, path, section, moduleOptions, cssObject)
        ) : this.getLayers(atts, children, path, section, moduleOptions, cssObject), this.getBottomShapeDivider(atts, cssObject)]
      )
    );
  },

render: function render() {
    var path = this.props.path,
        section = this.props.section,
        moduleName = section.get('name'),
        idString = section.get('id'),
        children = section.get('inner'),
        moduleOptions = this.props.moduleOptions,
        attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']),
        atts = getAttsBasedOnDisplay(section.get('atts'), this.props.targetDisplay, attsFromModuleOptions),
        moduleStyles = getModuleStyle(section, this.props.targetDisplay, moduleOptions),
        cssObject = getConcatenatedCSS(moduleStyles),
        sectionClass = this.getSectionClass(atts);

return this.renderHelper(atts, cssObject.style, sectionClass, children, path, idString, section, moduleOptions, cssObject.class);
  }

});
module.exports = Section;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 232 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var Section = __webpack_require__(231),
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    Immutable = __webpack_require__(3);
var Sections = React.createClass({
    displayName: 'Sections',

propTypes: {
        pageContent: mapChecker,
        moduleOptions: mapChecker,
        pathFromSelectionState: listChecker,
        targetDisplay: React.PropTypes.string,
        dropEffect: React.PropTypes.string
    },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
        result = !(Immutable.is(this.props.pathFromSelectionState, nextProps.pathFromSelectionState) && Immutable.is(this.props.pageContent, nextProps.pageContent) && this.props.targetDisplay == nextProps.targetDisplay && this.props.dropEffect == nextProps.dropEffect);
        return result;
    },

render: function render() {
        var children = this.props.pageContent.get('inner'),
            moduleOptions = this.props.moduleOptions || Immutable.Map();

return React.createElement(
            'div',
            null,
            children.map(function (section) {
                var sectionPath = Immutable.List();
                sectionPath = sectionPath.push(children.indexOf(section));
                return React.createElement(Section, { key: section.get('id'), pathFromSelectionState: this.props.pathFromSelectionState, dropEffect: this.props.dropEffect, targetDisplay: this.props.targetDisplay, path: sectionPath, section: section, moduleOptions: moduleOptions });
            }.bind(this))
        );
    }

});
module.exports = Sections;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 233 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery) {

var _tooltip = __webpack_require__(58);

var _tooltip2 = _interopRequireDefault(_tooltip);

__webpack_require__(59);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var FontToolView = __webpack_require__(221),
    getSelectionTop = __webpack_require__(32).getSelectionTop,
    findDOMNode = ReactDOM.findDOMNode,
    getBookmark = __webpack_require__(32).getBookmark,
    FlipMove = __webpack_require__(492),
    moveToBookmark = __webpack_require__(32).moveToBookmark,
    getSelectedNodeDetails = __webpack_require__(32).getSelectedNodeDetails,
    getSelectionAndContainerWidth = __webpack_require__(32).getSelectionAndContainerWidth,
    ColorPicker = __webpack_require__(216),
    Swatches = __webpack_require__(355),
    Palettes = __webpack_require__(354),
    AddLink = __webpack_require__(225);

var ToolBar = React.createClass({
    displayName: 'ToolBar',

calPos: false,
    currentBookMark: null,
    position: '',

getInitialState: function getInitialState() {
        return {
            isSwatchVisible: true,
            isPaletteVisible: false
        };
    },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

if (nextProps.toolBarState.get('show') && nextProps.toolBarState.get('retrigger')) {
            this.calPos = true;
            var selectedTop = getSelectionTop(),
                value = findDOMNode(this).clientHeight + 30;
            if (0 < selectedTop - value) {
                this.position = 'above';
            } else {
                this.position = 'below';
            }
        }
        if (!this.props.toolBarState.get('show') && nextProps.toolBarState.get('show')) {
            var selectedTop = getSelectionTop();
            if (0 < selectedTop - 68) {
                this.position = 'above';
            } else {
                this.position = 'below';
            }
            this.calPos = true;
        }
        if (nextProps.toolBarState.get('show') && (this.props.toolBarState.get('url') != nextProps.toolBarState.get('url') || this.props.toolBarState.get('colorPicker') != nextProps.toolBarState.get('colorPicker') || this.props.toolBarState.get('alignment') != nextProps.toolBarState.get('alignment') || this.props.toolBarState.get('listType') != nextProps.toolBarState.get('listType') || this.props.toolBarState.get('font') != nextProps.toolBarState.get('font'))) {
            this.calPos = true;
            var selectedTop = getSelectionTop(),
                value = 68;
            if (!this.props.toolBarState.get('colorPicker') && nextProps.toolBarState.get('colorPicker')) {
                value = 253;
            } else if (!this.props.toolBarState.get('font') && nextProps.toolBarState.get('font')) {
                value = 92;
            }
            if (0 < selectedTop - value) {
                this.position = 'above';
            } else {
                this.position = 'below';
            }
        }
    },

componentDidUpdate: function componentDidUpdate() {

if (this.calPos) {
            this.calPos = false;
            var TOOLBAR_CENTER = 188,
                TOOLBAR_WIDTH = 376;
            var selectionAndContainerWidth = getSelectionAndContainerWidth(this.props.toolBarState.get('activeEditorId')),
                containerWidth = selectionAndContainerWidth.containerWidth,
                threshold = selectionAndContainerWidth.containerLeft + TOOLBAR_CENTER,
                selectionWidth = selectionAndContainerWidth.selectionWidth,
                toolBarNode = findDOMNode(this),
                curTop = this.props.toolBarState.get('top'),
                curLeft = this.props.toolBarState.get('left');
            if ('above' == this.position) {
                curTop = curTop - 30;
            } else {
                curTop = curTop + 30 + findDOMNode(this).clientHeight;
            }
            if (selectionAndContainerWidth.isCollapsed) {
                if (curLeft < threshold) {
                    curLeft = threshold;
                } else if (TOOLBAR_CENTER > containerWidth - curLeft) {
                    curLeft = containerWidth - TOOLBAR_CENTER;
                }
            } else {
                if (TOOLBAR_WIDTH > selectionWidth) {
                    if (curLeft < threshold) {
                        curLeft = threshold - selectionWidth / 2;
                    } else if (TOOLBAR_WIDTH > containerWidth - curLeft) {
                        curLeft = containerWidth - (TOOLBAR_CENTER + selectionWidth / 2);
                    }
                }
            }

curLeft = curLeft + selectionWidth / 2;
            if (TOOLBAR_CENTER > containerWidth - curLeft) {
                curLeft = selectionAndContainerWidth.containerLeft + TOOLBAR_CENTER;
            }
            toolBarNode.style.top = curTop + 'px';
            toolBarNode.style.left = curLeft + 'px';
        }
    },

_addLink: function _addLink(linkText, newTab) {

var curBookMark = this.currentBookMark;
        this.currentBookMark = null;
        moveToBookmark(curBookMark, this.props.toolBarState.get('activeEditorId'));
        this.props.applyAnchor(linkText, newTab);
        this.props.useOverride(false);
    },

handleF: function handleF(exploit, event) {

event.stopPropagation();
        if (!this.props.toolBarState.get('override')) {
            this.currentBookMark = getBookmark(this.props.toolBarState.get('activeEditorId'));
            this.props.useOverride(exploit);
        }
    },

_handleListBlock: function _handleListBlock(blockType, event) {

this.props.handleListBlock(blockType);
    },

handleMD: function handleMD(event) {

if (this.currentBookMark) {
            var currentValue = event.target.value;
            moveToBookmark(this.currentBookMark, this.props.toolBarState.get('activeEditorId'));
            this.currentBookMark = null;
            if (this.props.toolBarState.get('override')) {
                this.props.useOverride(false);
            }
        }
        event.preventDefault();
        event.stopPropagation();
    },

_handleActualBlur: function _handleActualBlur() {

var targetDocument = document.getElementById('tatsu-preview').contentDocument;
        if (this.currentBookMark && this.props.toolBarState.get('activeEditorId') == targetDocument.activeElement.id) {
            this.currentBookMark = null;
            this.props.useOverride(false);
            this.props.toggleTool('url');
        } else if (this.currentBookMark) {
            this.currentBookMark = null;
            this.props.resetState();
        }
    },

_handleBlur: function _handleBlur(event) {

setTimeout(this._handleActualBlur, 0);
    },

_getCurrentLinkData: function _getCurrentLinkData() {

_preventDefault: function _preventDefault(event) {

event.preventDefault();
    },

handleClose: function handleClose(event, tool) {
        event.preventDefault();
        event.stopPropagation();
        this.props.toggleTool('colorhubThings');
    },

getClassData: function getClassData() {

var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
            result = { typehub: '', colorhub: '', inlineLink: '' },
            currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId')),
            domElement;
        if (currentEditor.selection.getStart(false).nodeName === 'A') {

if (jQuery(currentEditor.selection.getStart(false)).find('span').length) {
                domElement = jQuery(currentEditor.selection.getStart(false)).find('span')[0];
            } else if (jQuery(currentEditor.selection.getStart(false)).closest('span').length) {
                domElement = jQuery(currentEditor.selection.getStart(false)).closest('span')[0];
            } else {
                domElement = currentEditor.selection.getStart(false);
            }
        } else {
            domElement = currentEditor.selection.getStart(false);
        }
        var classes = domElement.className;
        classes = classes.split(' ');

if (tabName === 'swatch') {
            this.setState({
                isSwatchVisible: true,
                isPaletteVisible: false
            });
        } else {
            this.setState({
                isSwatchVisible: false,
                isPaletteVisible: true
            });
        }
    },
    render: function render() {
        var toolBar = this.props.toolBarState,
            isVisible = toolBar.get('show'),
            selectedNodeDetails = getSelectedNodeDetails(toolBar.get('activeEditorId')),
            wrapWidth = { width: 380 },
            hasColorhub = jQuery('#tatsu-preview').contents().find('#colorhub-output').length,
            classNames = 'tatsu-inline-wrapper ';
        toolBar.forEach(function (value, key) {

if (-1 < ['url', 'colorPicker', 'alignment', 'listType', 'font', 'colorhubThings'].indexOf(key) && toolBar.get(key)) {
                classNames = classNames + key + 'Open ';
            }
        });
        if ('below' == this.position) {
            classNames = classNames + 'below ';
        }

if (-1 != classNames.indexOf('fontOpen')) {
            wrapWidth = { width: window.typehub_selectors ? 386 : 365 };
        } else if (classNames.trim().split(" ").length === 1) {
            wrapWidth = { width: hasColorhub ? 436 : 406 };
        } else {
            wrapWidth = {};
        }

if (!isVisible) {
            return null;
        } else {
            var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';
            return React.createElement(
                'div',
                { className: classNames, style: wrapWidth, onMouseDown: this._preventDefault },
                toolBar.get('alignment') ? React.createElement(
                    FlipMove,
                    { className: 'tatsu-inline-inner-wrap', style: { display: 'flex' }, disableAllAnimations: true, appearAnimation: 'elevator', staggerDelayBy: 30 },
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Align Right' },
                        React.createElement(
                            'div',
                            { className: 'tatsu-inline-button', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, key: 'align-left', onMouseDown: this.handleMD, onMouseUp: this.props.applyProp.bind(null, 'alignleft') },
                            React.createElement(
                                'svg',
                                { fill: 'left' == selectedNodeDetails.style.textAlign ? primaryColor : '#c4c4c4', style: { height: '24px', width: '20px' }, viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M6,27h23c1.104,0,2-0.896,2-2s-0.896-2-2-2H6c-1.104,0-2,0.896-2,2S4.896,27,6,27z M44,14H6c-1.104,0-2,0.896-2,2    s0.896,2,2,2h38c1.104,0,2-0.896,2-2S45.104,14,44,14z M34,32H6c-1.104,0-2,0.896-2,2s0.896,2,2,2h28c1.104,0,2-0.896,2-2    S35.104,32,34,32z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Center' },
                        React.createElement(
                            'div',
                            { className: 'tatsu-inline-button', key: 'align-center', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.applyProp.bind(null, 'aligncenter') },
                            React.createElement(
                                'svg',
                                { fill: 'center' == selectedNodeDetails.style.textAlign ? primaryColor : '#c4c4c4', style: { height: '24px', width: '20px' }, viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M36,27c1.104,0,2-0.896,2-2s-0.896-2-2-2H13c-1.104,0-2,0.896-2,2s0.896,2,2,2H36z M44,14H6c-1.104,0-2,0.896-2,2    s0.896,2,2,2h38c1.104,0,2-0.896,2-2S45.104,14,44,14z M39,32H11c-1.104,0-2,0.896-2,2s0.896,2,2,2h28c1.104,0,2-0.896,2-2    S40.104,32,39,32z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Align Right' },
                        React.createElement(
                            'div',
                            { key: 'align-right', className: 'tatsu-inline-button', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.applyProp.bind(null, 'alignright') },
                            React.createElement(
                                'svg',
                                { fill: 'right' == selectedNodeDetails.style.textAlign ? primaryColor : '#c4c4c4', style: { height: '24px', width: '20px' }, viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M44,23H21c-1.104,0-2,0.896-2,2s0.896,2,2,2h23c1.104,0,2-0.896,2-2S45.104,23,44,23z M46,16c0-1.104-0.896-2-2-2H6  c-1.104,0-2,0.896-2,2s0.896,2,2,2h38C45.104,18,46,17.104,46,16z M44,32H16c-1.104,0-2,0.896-2,2s0.896,2,2,2h28  c1.104,0,2-0.896,2-2S45.104,32,44,32z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Align Justify' },
                        React.createElement(
                            'div',
                            { key: 'align-justify', className: 'tatsu-inline-button', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.applyProp.bind(null, 'alignjustify') },
                            React.createElement(
                                'svg',
                                { fill: 'justify' == selectedNodeDetails.style.textAlign ? primaryColor : '#c4c4c4', style: { height: '24px', width: '20px' }, viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M44,23H6c-1.104,0-2,0.896-2,2s0.896,2,2,2h38c1.104,0,2-0.896,2-2S45.104,23,44,23z M6,18h38c1.104,0,2-0.896,2-2  s-0.896-2-2-2H6c-1.104,0-2,0.896-2,2S4.896,18,6,18z M44,32H6c-1.104,0-2,0.896-2,2s0.896,2,2,2h38c1.104,0,2-0.896,2-2  S45.104,32,44,32z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Close' },
                        React.createElement(
                            'div',
                            { key: 'close', className: 'tatsu-inline-button', style: { width: '36px', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'alignment') },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', style: { height: '24px', width: '20px' }, onClick: this.props.toggleTool.bind(null, '', 1), className: 'tatsu-svg-icon', viewBox: '0 0 20 20' },
                                React.createElement('path', { d: 'M15.898,4.045c-0.271-0.272-0.713-0.272-0.986,0l-4.71,4.711L5.493,4.045c-0.272-0.272-0.714-0.272-0.986,0s-0.272,0.714,0,0.986l4.709,4.711l-4.71,4.711c-0.272,0.271-0.272,0.713,0,0.986c0.136,0.136,0.314,0.203,0.492,0.203c0.179,0,0.357-0.067,0.493-0.203l4.711-4.711l4.71,4.711c0.137,0.136,0.314,0.203,0.494,0.203c0.178,0,0.355-0.067,0.492-0.203c0.273-0.273,0.273-0.715,0-0.986l-4.711-4.711l4.711-4.711C16.172,4.759,16.172,4.317,15.898,4.045z' })
                            )
                        )
                    )
                ) : toolBar.get('listType') ? React.createElement(
                    FlipMove,
                    { disableAllAnimations: true, style: { display: 'flex' }, className: 'tatsu-inline-inner-wrap', appearAnimation: 'elevator', staggerDelayBy: 30 },
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Unordered List' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, key: 'bullet-list', style: { width: '36px', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onClick: this.props.toggleList.bind(null, 'ul') },
                            React.createElement(
                                'svg',
                                { viewBox: '0 0 50 50', style: { height: '24px', width: '20px' }, fill: 'ul' == selectedNodeDetails.listType ? primaryColor : '#c4c4c4' },
                                React.createElement('path', { d: 'M44,23H16c-1.104,0-2,0.896-2,2s0.896,2,2,2h28c1.104,0,2-0.896,2-2S45.104,23,44,23z M16,18h28c1.104,0,2-0.896,2-2  s-0.896-2-2-2H16c-1.104,0-2,0.896-2,2S14.896,18,16,18z M44,32H16c-1.104,0-2,0.896-2,2s0.896,2,2,2h28c1.104,0,2-0.896,2-2  S45.104,32,44,32z M8,13c-1.657,0-3,1.343-3,3s1.343,3,3,3s3-1.343,3-3S9.657,13,8,13z M8,22c-1.657,0-3,1.343-3,3s1.343,3,3,3  s3-1.343,3-3S9.657,22,8,22z M8,31c-1.657,0-3,1.343-3,3s1.343,3,3,3s3-1.343,3-3S9.657,31,8,31z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Ordered List' },
                        React.createElement(
                            'div',
                            { key: 'number-list', style: { width: '36px', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onClick: this.props.toggleList.bind(null, 'ol') },
                            React.createElement(
                                'svg',
                                { viewBox: '0 0 381.304 381.304', style: { height: '24px', width: '20px' }, fill: 'ol' == selectedNodeDetails.listType ? primaryColor : '#c4c4c4' },
                                React.createElement('path', { d: 'M121.203,37.858c0-7.791,6.319-14.103,14.104-14.103H367.2c7.784,0,14.104,6.312,14.104,14.103\r s-6.312,14.103-14.104,14.103H135.307C127.522,51.961,121.203,45.649,121.203,37.858z M135.307,120.908h150.426\r c7.79,0,14.104-6.315,14.104-14.104c0-7.79-6.313-14.103-14.104-14.103H135.307c-7.785,0-14.104,6.307-14.104,14.103\r C121.203,114.598,127.522,120.908,135.307,120.908z M367.2,269.75H135.307c-7.785,0-14.104,6.312-14.104,14.104\r c0,7.79,6.319,14.103,14.104,14.103H367.2c7.784,0,14.104-6.312,14.104-14.103C381.304,276.062,374.984,269.75,367.2,269.75z\r M285.727,338.693h-150.42c-7.785,0-14.104,6.307-14.104,14.104c0,7.79,6.319,14.103,14.104,14.103h150.426\r c7.79,0,14.104-6.312,14.104-14.103C299.836,345.005,293.517,338.693,285.727,338.693z M33.866,127.838h22.387V14.405H37.921\r c-0.521,5.925-0.068,10.689-4.696,14.277c-4.631,3.591-14.363,5.382-23.158,5.382H6.871v15.681h26.995V127.838z M25.603,345.147\r l28.115-20.912c9.69-6.655,16.056-12.826,19.109-18.524c3.05-5.697,4.569-11.821,4.569-18.377c0-10.716-3.585-19.357-10.737-25.941\r c-7.161-6.579-16.568-9.865-28.23-9.865c-11.245,0-20.241,3.328-26.982,9.989c-6.75,6.655-10.113,16.691-10.113,30.115H23.02\r c0-8.015,1.416-13.548,4.253-16.621c2.834-3.067,6.721-4.604,11.665-4.604s8.854,1.561,11.741,4.676\r c2.888,3.12,4.327,6.998,4.327,11.632c0,4.628-1.336,8.808-4.02,12.555c-2.675,3.747-10.125,10.071-22.352,18.962\r c-10.453,7.648-24.154,16.964-28.393,23.726L0,364.96h77.632v-19.813H25.603L25.603,345.147z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Close' },
                        React.createElement(
                            'div',
                            { key: 'close', style: { width: '36px', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'listType') },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', style: { height: '24px', width: '20px' }, className: 'tatsu-svg-icon', viewBox: '0 0 20 20' },
                                React.createElement('path', { d: 'M15.898,4.045c-0.271-0.272-0.713-0.272-0.986,0l-4.71,4.711L5.493,4.045c-0.272-0.272-0.714-0.272-0.986,0s-0.272,0.714,0,0.986l4.709,4.711l-4.71,4.711c-0.272,0.271-0.272,0.713,0,0.986c0.136,0.136,0.314,0.203,0.492,0.203c0.179,0,0.357-0.067,0.493-0.203l4.711-4.711l4.71,4.711c0.137,0.136,0.314,0.203,0.494,0.203c0.178,0,0.355-0.067,0.492-0.203c0.273-0.273,0.273-0.715,0-0.986l-4.711-4.711l4.711-4.711C16.172,4.759,16.172,4.317,15.898,4.045z' })
                            )
                        )
                    )
                ) : toolBar.get('font') ? React.createElement(FontToolView, {
                    blockType: selectedNodeDetails.type,
                    loadFont: this.props.loadFont,
                    currentTypehubSelector: this.getClassData().typehub,
                    currentFontSize: selectedNodeDetails.style.fontSize,
                    currentLetterSpacing: selectedNodeDetails.style.letterSpacing,
                    currentLineHeight: selectedNodeDetails.style.lineHeight,
                    toggleTool: this.props.toggleTool,
                    applyClass: this.props.applyClass,
                    applyProp: this.props.applyProp,
                    activeEditorId: toolBar.get('activeEditorId'),
                    resetState: this.props.resetState,
                    toggleBlockType: this.props.toggleBlockType,
                    isOverriden: toolBar.get('override'),
                    useOverride: this.props.useOverride }) : toolBar.get('url') ? React.createElement(
                    'div',
                    { className: 'tatsu-inline-inner-wrap tatsu-linkinput-wrap' },
                    React.createElement(AddLink, {
                        handleBlur: this._handleBlur,
                        handleF: this.handleF,
                        addLink: this._addLink,
                        getCurrentLinkData: this._getCurrentLinkData,
                        handleMD: this.handleMD,
                        toggleTool: this.props.toggleTool,
                        toolBarState: this.props.toolBarState,
                        preventDefault: this._preventDefault,
                        currentClass: this.getClassData().inlineLink,
                        applyClass: this.props.applyClass
                    })
                ) : toolBar.get('colorPicker') ? React.createElement(
                    'div',
                    { className: 'tatsu-inline-inner-wrap' },
                    React.createElement(ColorPicker, { isOverriden: toolBar.get('override'), resetState: this.props.resetState, useOverride: this.props.useOverride, activeEditorId: toolBar.get('activeEditorId'), toggleTool: this.props.toggleTool, applyColor: this.props.applyFontColor })
                ) : toolBar.get('colorhubThings') ? React.createElement(
                    'div',
                    { className: 'tatsu-inline-inner-wrap' },
                    React.createElement(
                        'div',
                        { className: 'tatsu-inline-swatch-close-button', onMouseDown: this.handleMD, onMouseUp: this._preventDefault, onClick: this.handleClose, style: { position: 'absolute', right: -10, top: -10, background: primaryColor, borderRadius: 10, height: 20, width: 20, cursor: 'pointer' } },
                        '  ',
                        React.createElement(
                            'svg',
                            { fill: '#fff', style: { height: '20px', width: '16px', position: 'absolute', top: 0, left: 2 }, className: 'tatsu-svg-icon', viewBox: '0 0 20 20' },
                            React.createElement('path', { d: 'M15.898,4.045c-0.271-0.272-0.713-0.272-0.986,0l-4.71,4.711L5.493,4.045c-0.272-0.272-0.714-0.272-0.986,0s-0.272,0.714,0,0.986l4.709,4.711l-4.71,4.711c-0.272,0.271-0.272,0.713,0,0.986c0.136,0.136,0.314,0.203,0.492,0.203c0.179,0,0.357-0.067,0.493-0.203l4.711-4.711l4.71,4.711c0.137,0.136,0.314,0.203,0.494,0.203c0.178,0,0.355-0.067,0.492-0.203c0.273-0.273,0.273-0.715,0-0.986l-4.711-4.711l4.711-4.711C16.172,4.759,16.172,4.317,15.898,4.045z' })
                        )
                    ),
                    React.createElement(
                        'div',
                        { className: 'be-color-picker-tab' },
                        React.createElement(
                            'span',
                            { onClick: this.colorPickerTabClick.bind(this, 'swatch'), className: this.state.isSwatchVisible ? "visible-palette" : "" },
                            'Swatch'
                        ),
                        React.createElement(
                            'span',
                            { onClick: this.colorPickerTabClick.bind(this, 'palette'), className: this.state.isPaletteVisible ? "visible-palette" : "" },
                            'Palette'
                        )
                    ),
                    this.state.isSwatchVisible ? React.createElement(Swatches, {
                        swatchClick: function (e) {
                            var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
                                currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId'));
                            currentEditor.formatter.remove('forecolor');
                            this.props.applyClass('swatch-' + e.key);
                        }.bind(this),
                        enableGradient: true,
                        colorHub: window.colorhub,
                        selectedSwatch: this.getClassData().colorhub,
                        toolbarState: this.props.toolbarState,
                        resetState: this.props.resetState,
                        useOverride: this.props.useOverride,
                        toggleTool: this.props.toggleTool,
                        isOverriden: toolBar.get('override'),
                        activeEditorId: toolBar.get('activeEditorId')
                    }) : React.createElement(Palettes, {
                        paletteClick: function (index) {
                            var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
                                currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId'));
                            currentEditor.formatter.remove('forecolor');
                            this.props.applyClass('palette-' + index);
                        }.bind(this),
                        enableGradient: true,
                        colorHub: window.colorhub,
                        selectedPalette: this.getClassData().colorhub,
                        toolbarState: this.props.toolbarState,
                        resetState: this.props.resetState,
                        useOverride: this.props.useOverride,
                        toggleTool: this.props.toggleTool,
                        isOverriden: toolBar.get('override'),
                        activeEditorId: toolBar.get('activeEditorId')
                    })
                ) : React.createElement(
                    FlipMove,
                    { className: 'tatsu-inline-inner-wrap', style: { display: 'flex' }, disableAllAnimations: true },
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Bold' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'bold', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.togglePrimitives.bind(null, 'bold') },
                            React.createElement(
                                'svg',
                                { fill: selectedNodeDetails.style.bold ? primaryColor : '#c4c4c4', viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M30.112,24.151C31.288,22.758,32,20.961,32,19c0-4.411-3.589-8-8-8h-9v12v4v12h11c4.411,0,8-3.589,8-8  C34,28.094,32.437,25.552,30.112,24.151z M19,15h5c2.206,0,4,1.794,4,4s-1.794,4-4,4h-5V15z M26,35h-7v-8h5h2c2.206,0,4,1.794,4,4  S28.206,35,26,35z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Underline' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'underline', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.togglePrimitives.bind(null, 'underline') },
                            React.createElement(
                                'svg',
                                { fill: 'underline' == selectedNodeDetails.style.textDecoration ? primaryColor : '#c4c4c4', viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M36,35H14c-1.104,0-2,0.896-2,2s0.896,2,2,2h22c1.104,0,2-0.896,2-2S37.104,35,36,35z M25,33c4.963,0,9-4.038,9-9V11  c0-1.104-0.896-2-2-2s-2,0.896-2,2v13c0,2.757-2.243,5-5,5s-5-2.243-5-5V11c0-1.104-0.896-2-2-2s-2,0.896-2,2v13  C16,28.962,20.037,33,25,33z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Strike Through' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'linethrough', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.togglePrimitives.bind(null, 'strikethrough') },
                            React.createElement(
                                'svg',
                                { fill: 'line-through' == selectedNodeDetails.style.textDecoration ? primaryColor : '#c4c4c4', viewBox: '-3 -2 28 28' },
                                React.createElement('path', { fill: 'none', d: 'M0 0h24v24H0V0z' }),
                                React.createElement('path', { d: 'M10 19h4v-3h-4v3zM5 4v3h5v3h4V7h5V4H5zM3 14h18v-2H3v2z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Italic' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'italic', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.togglePrimitives.bind(null, 'italic') },
                            React.createElement(
                                'svg',
                                { fill: selectedNodeDetails.style.italic ? primaryColor : '#c4c4c4', viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M26.393,15.039c-1.088-0.222-2.138,0.486-2.354,1.569l-4,20c-0.217,1.083,0.485,2.137,1.568,2.353  C21.74,38.988,21.872,39,22.002,39c0.934,0,1.77-0.658,1.959-1.608l4-20C28.178,16.309,27.476,15.255,26.393,15.039z M27,9  c-1.105,0-2,0.895-2,2s0.895,2,2,2s2-0.895,2-2S28.105,9,27,9z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Quotes' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'quotes', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleBlockType.bind(null, 'blockquote') },
                            React.createElement(
                                'svg',
                                { fill: selectedNodeDetails.isBlockquote ? primaryColor : '#c4c4c4', viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M32,14c-3.314,0-6,2.686-6,6s2.686,6,6,6c0.702,0,1.374-0.127,2-0.349V26c0,3.309-2.691,6-6,6c-1.104,0-2,0.896-2,2  s0.896,2,2,2c5.514,0,10-4.486,10-10v-6C38,16.686,35.314,14,32,14z M18,14c-3.314,0-6,2.686-6,6s2.686,6,6,6  c0.702,0,1.374-0.127,2-0.349V26c0,3.309-2.691,6-6,6c-1.104,0-2,0.896-2,2s0.896,2,2,2c5.514,0,10-4.486,10-10v-6  C24,16.686,21.314,14,18,14z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Text Alignment' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'alignment', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'alignment') },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M36,27c1.104,0,2-0.896,2-2s-0.896-2-2-2H13c-1.104,0-2,0.896-2,2s0.896,2,2,2H36z M44,14H6c-1.104,0-2,0.896-2,2    s0.896,2,2,2h38c1.104,0,2-0.896,2-2S45.104,14,44,14z M39,32H11c-1.104,0-2,0.896-2,2s0.896,2,2,2h28c1.104,0,2-0.896,2-2    S40.104,32,39,32z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Add Link' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'link', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'url') },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M23.034,31.209c0.042,0.819-0.238,1.652-0.862,2.276l-3.536,3.536c-1.133,1.133-3.109,1.133-4.242,0l-1.414-1.415  c-0.566-0.566-0.879-1.32-0.879-2.121s0.312-1.555,0.879-2.122l3.535-3.536c0.566-0.566,1.32-0.878,2.121-0.878  c0.053,0,0.104,0.013,0.157,0.015l3.174-3.174c-1.011-0.548-2.148-0.841-3.331-0.841c-1.87,0-3.628,0.728-4.949,2.05l-3.535,3.535  c-1.322,1.322-2.051,3.08-2.051,4.95c0,1.87,0.729,3.628,2.051,4.95l1.414,1.414c1.321,1.322,3.079,2.05,4.949,2.05  s3.628-0.728,4.949-2.05L25,36.314c2.237-2.237,2.637-5.624,1.205-8.276L23.034,31.209z M18.636,31.364  c0.391,0.391,0.902,0.586,1.414,0.586s1.023-0.195,1.414-0.586l9.9-9.899c0.781-0.781,0.781-2.047,0-2.828  c-0.781-0.781-2.047-0.781-2.828,0l-9.9,9.899C17.854,29.316,17.854,30.583,18.636,31.364z M39.849,11.565l-1.414-1.414  c-1.321-1.322-3.079-2.05-4.949-2.05c-1.87,0-3.628,0.728-4.949,2.05L25,13.687c-2.237,2.237-2.637,5.624-1.205,8.276l3.172-3.172  c-0.042-0.819,0.238-1.652,0.862-2.276l3.536-3.536c0.566-0.566,1.32-0.878,2.121-0.878s1.555,0.312,2.121,0.878l1.414,1.415  c0.566,0.566,0.879,1.32,0.879,2.121s-0.312,1.555-0.879,2.121l-3.535,3.536c-0.599,0.599-1.432,0.872-2.252,0.838l-3.2,3.2  c1.011,0.548,2.148,0.841,3.331,0.841c1.87,0,3.628-0.728,4.949-2.05l3.535-3.536c1.322-1.322,2.051-3.08,2.051-4.95  C41.899,14.645,41.171,12.887,39.849,11.565z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Text Color' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'textcolor', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'colorPicker') },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', style: { height: 20, marginBottom: 2, marginLeft: 2 }, viewBox: '0 0 32 32' },
                                React.createElement('path', { d: 'M15 26c-.912 0-1.77-.355-2.415-1.001l-7.585-7.584c-.654-.655-1-1.49-1-2.415 0-.912.355-1.77 1-2.415l8.586-8.585-2.293-2.293c-.391-.391-.391-1.023 0-1.414s1.023-.391 1.414 0l12.938 12.937c.976.976.976 2.563 0 3.539l-8.229 8.229c-.646.647-1.504 1.002-2.416 1.002zm0-20.586l-8.585 8.586c-.271.271-.415.617-.415 1 0 .399.132.718.415 1l7.585 7.585c.535.535 1.466.535 2 0l8.23-8.229c.196-.196.196-.515 0-.711l-9.23-9.231zM24 32h-18c-.552 0-1-.447-1-1s.448-1 1-1h18c.553 0 1 .447 1 1s-.447 1-1 1zM23.5 24.333c0-1.929 2.145-3.433 2.5-5.333.359 1.903 2.5 3.417 2.5 5.333 0 1.473-1.119 2.667-2.5 2.667s-2.5-1.194-2.5-2.667zM24.966 16.034l-8.259 8.259c-.943.943-2.472.943-3.415 0l-7.585-7.585c-.471-.472-.707-1.708-.707-1.708h19.538c.539 0 .81.652.428 1.034z' })
                            )
                        )
                    ),
                    !!hasColorhub && React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Swatches & Palettes' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'colorhub', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'colorhubThings') },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', height: '17', width: '16', style: { marginBottom: 3 }, viewBox: '0 0 17 16' },
                                React.createElement(
                                    'g',
                                    { xmlns: 'http://www.w3.org/2000/svg', fill: '#C4C4C4', fillRule: 'evenodd' },
                                    React.createElement('circle', { cx: '8', cy: '5', r: '5' }),
                                    React.createElement('circle', { cx: '12', cy: '11', r: '5', opacity: '.7' }),
                                    React.createElement('circle', { cx: '5', cy: '11', r: '5', opacity: '.3' })
                                )
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Typography' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'font', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'font') },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M37,11h-4h-2H19h-2h-4c-1.104,0-2,0.896-2,2v4c0,1.104,0.896,2,2,2s2-0.896,2-2c0-1.103,0.897-2,2-2h2h4v20h-2  c-1.104,0-2,0.896-2,2s0.896,2,2,2h8c1.104,0,2-0.896,2-2s-0.896-2-2-2h-2V15h4h2c1.103,0,2,0.897,2,2c0,1.104,0.896,2,2,2  s2-0.896,2-2v-4C39,11.896,38.104,11,37,11z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'List type' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'list', style: { width: '36px', borderRight: '1px solid #32373d', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.toggleTool.bind(null, 'listType') },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', viewBox: '0 0 50 50' },
                                React.createElement('path', { d: 'M44,23H16c-1.104,0-2,0.896-2,2s0.896,2,2,2h28c1.104,0,2-0.896,2-2S45.104,23,44,23z M16,18h28c1.104,0,2-0.896,2-2  s-0.896-2-2-2H16c-1.104,0-2,0.896-2,2S14.896,18,16,18z M44,32H16c-1.104,0-2,0.896-2,2s0.896,2,2,2h28c1.104,0,2-0.896,2-2  S45.104,32,44,32z M8,13c-1.657,0-3,1.343-3,3s1.343,3,3,3s3-1.343,3-3S9.657,13,8,13z M8,22c-1.657,0-3,1.343-3,3s1.343,3,3,3  s3-1.343,3-3S9.657,22,8,22z M8,31c-1.657,0-3,1.343-3,3s1.343,3,3,3s3-1.343,3-3S9.657,31,8,31z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Clear Styles' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'clear', style: { width: '36px', height: '36px', padding: '6px', borderRight: '1px solid #32373d' }, onMouseDown: this.handleMD, onMouseUp: this.props.clearStyle },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', viewBox: '0 0 100 100' },
                                React.createElement('path', { d: 'M90.812,26.636L73.161,8.991c-4.115-4.119-11.293-4.111-15.404,0L9.067,57.677c-4.248,4.25-4.248,11.162,0,15.406   L26.72,90.735c2.055,2.055,4.791,3.189,7.697,3.189c2.912,0,5.648-1.135,7.703-3.189l48.691-48.691   C95.062,37.8,95.062,30.886,90.812,26.636z M39.524,88.132c-2.725,2.727-7.479,2.73-10.209,0L11.671,70.487   c-2.818-2.818-2.818-7.396,0-10.209l33.004-33.01l27.859,27.855L39.524,88.132z' })
                            )
                        )
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { getPopupContainer: function getPopupContainer(triggerNode) {
                                return triggerNode.parentElement;
                            }, title: 'Close' },
                        React.createElement(
                            'div',
                            { iconStyle: { height: '24px', width: '20px' }, className: 'tatsu-inline-button', key: 'remove', style: { width: '36px', height: '36px', padding: '6px' }, onMouseDown: this.handleMD, onMouseUp: this.props.resetState },
                            React.createElement(
                                'svg',
                                { fill: '#c4c4c4', className: 'tatsu-svg-icon', viewBox: '0 0 20 20' },
                                React.createElement('path', { d: 'M15.898,4.045c-0.271-0.272-0.713-0.272-0.986,0l-4.71,4.711L5.493,4.045c-0.272-0.272-0.714-0.272-0.986,0s-0.272,0.714,0,0.986l4.709,4.711l-4.71,4.711c-0.272,0.271-0.272,0.713,0,0.986c0.136,0.136,0.314,0.203,0.492,0.203c0.179,0,0.357-0.067,0.493-0.203l4.711-4.711l4.71,4.711c0.137,0.136,0.314,0.203,0.494,0.203c0.178,0,0.355-0.067,0.492-0.203c0.273-0.273,0.273-0.715,0-0.986l-4.711-4.711l4.711-4.711C16.172,4.759,16.172,4.317,15.898,4.045z' })
                            )
                        )
                    )
                )
            );
        }
    }

});
module.exports = ToolBar;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 234 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var ToolBar = __webpack_require__(233),
    pushContentFromInlineEditor = __webpack_require__(2).pushContentFromInlineEditor,
    store = __webpack_require__(11),
    getSelectedNodeDetails = __webpack_require__(32).getSelectedNodeDetails,
    useOverride = __webpack_require__(2).toggleInlineOverride,
    resetRetrigger = __webpack_require__(2).resetRetriggerInlineToolbar,
    toggleTool = __webpack_require__(2).toggleInlineTool;
var ToolBarWrapper = React.createClass({
    displayName: 'ToolBarWrapper',

shouldComponentUpdate: function shouldComponentUpdate(nextProps) {

return !Immutable.is(this.props.toolBarState, nextProps.toolBarState);
    },

componentDidUpdate: function componentDidUpdate() {

if (this.props.toolBarState.get('retrigger')) {
            store.dispatch(resetRetrigger());
        }
    },

_applyFontColor: function _applyFontColor(colorString, event) {

_applyFontFamily: function _applyFontFamily(fontNameString) {

var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
            currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId'));
        currentEditor.formatter.apply('fontname', {
            value: fontNameString
        });
    },

_loadFont: function _loadFont(fontFamilyString) {

_toggleBlockType: function _toggleBlockType(blocktype, event) {

var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
            currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId'));
        currentEditor.formatter.toggle(blocktype);
        this.forceUpdate();
        store.dispatch(pushContentFromInlineEditor());
    },

_toggleStylePrimitives: function _toggleStylePrimitives(primitive, event) {

var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
            currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId'));
        currentEditor.formatter.toggle(primitive);
        this.forceUpdate();
        store.dispatch(pushContentFromInlineEditor());
    },

_clearStyle: function _clearStyle() {

var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
            currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId'));
        currentEditor.formatter.remove("removeformat");
        this.forceUpdate();
        store.dispatch(pushContentFromInlineEditor());
    },

_resetState: function _resetState() {

store.dispatch({
            type: 'RESET_INLINE_TOOLBAR'
        });
    },

_applyAnchor: function _applyAnchor(hrefString, newTab) {

if (newTab) {
            newTab = '_blank';
        } else {
            newTab = '_self';
        }

_applyProp: function _applyProp(prop, value) {

var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
            currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId'));
        currentEditor.formatter.apply(prop, {
            value: value
        });
        this.forceUpdate();
        store.dispatch(pushContentFromInlineEditor());
    },

_applyClass: function _applyClass(className, type) {
        var tinymce = document.getElementById('tatsu-preview').contentWindow.tinymce,
            currentEditor = tinymce.get(this.props.toolBarState.get('activeEditorId')),
            classArray,
            domElement = '';
        var temp = getSelectedNodeDetails(this.props.toolBarState.get('activeEditorId')).class;
        if (currentEditor.selection.getStart(false).nodeName === 'A') {
            domElement = currentEditor.selection.getStart(false).closest('span');
        } else {
            domElement = currentEditor.selection.getStart(false);
        }
        classArray = temp.split(' ');
        if (classArray.indexOf(className) > -1) {
            className = '';
        }
        if (type === 'typehub') {
            if (window.typehub_selectors && window.typehub_selectors.constructor === Object) {
                var typehubSelectors = Object.keys(window.typehub_selectors);
                if (temp) {
                    classArray.forEach(function (eachClass, index) {
                        typehubSelectors.forEach(function (selector) {
                            if (eachClass === selector) {
                                classArray[index] = '';
                            }
                        });
                    });
                    className = className + ' ' + classArray.filter(Boolean).join(' ');
                }
            }
        } else if (type === 'inlineLink') {
            if (temp) {
                var linkStyleClasses = ['tatsu-inline-link-style1', 'tatsu-inline-link-style2', 'tatsu-inline-link-style3'];
                classArray.forEach(function (eachClass, index) {
                    linkStyleClasses.forEach(function (selector) {
                        if (eachClass === selector) {
                            classArray[index] = '';
                        }
                    });
                });
                className = className + ' ' + classArray.filter(Boolean).join(' ');
            }
        } else {
            if (temp) {
                for (var item in classArray) {
                    if (classArray[item].startsWith('palette') || classArray[item].startsWith('swatch')) {
                        classArray[item] = '';
                    }
                }
                className = className + ' ' + classArray.filter(Boolean).join(' ');
            }
        }

//Applying classname twice to avoid tinyMCE errors. 
        currentEditor.formatter.apply('classname', {
            value: className
        });
        if (currentEditor.selection.getStart(false).nodeName === 'A') {
            domElement = currentEditor.selection.getStart(false).closest('span');
        } else {
            domElement = currentEditor.selection.getStart(false);
        }
        setTimeout(function () {
            if (['STRONG', 'EM'].indexOf(domElement.nodeName) !== -1) {
                if (domElement.children.length && domElement.children[0].nodeName === 'SPAN') {
                    domElement.children[0].className = '';
                } else {
                    domElement.parentElement.className = '';
                }
            } else {
                domElement.className = '';
            }
            currentEditor.formatter.apply('classname', {
                value: className
            });
        }, 0);

setTimeout(function () {
            this.forceUpdate();
            store.dispatch(pushContentFromInlineEditor());
        }.bind(this), 0);
    },

_toggleList: function _toggleList(listType) {

_useOverride: function _useOverride(exploit, event) {

store.dispatch(useOverride(exploit));
    },

_toggleTool: function _toggleTool(tool, event) {

store.dispatch(toggleTool(tool));
    },

render: function render() {

var toolBarState = this.props.toolBarState;
        return React.createElement(ToolBar, {
            toolBarState: toolBarState,
            resetState: this._resetState,
            isOverriden: toolBarState.get('override'),
            useOverride: this._useOverride,
            toggleTool: this._toggleTool,
            applyFontColor: this._applyFontColor,
            applyClass: this._applyClass,
            loadFont: this._loadFont,
            toggleBlockType: this._toggleBlockType,
            togglePrimitives: this._toggleStylePrimitives,
            applyProp: this._applyProp,
            applyAnchor: this._applyAnchor,
            toolBarState: toolBarState,
            toggleList: this._toggleList,
            clearStyle: this._clearStyle
        });
    }

});
module.exports = ToolBarWrapper;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 235 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _modal = __webpack_require__(118);

var _modal2 = _interopRequireDefault(_modal);

var _switch = __webpack_require__(209);

var _switch2 = _interopRequireDefault(_switch);

__webpack_require__(119);

__webpack_require__(210);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var openInNewTab = __webpack_require__(725),
    sendMessage = __webpack_require__(2).sendMessage,
    resetSelection = __webpack_require__(2).resetSelection,
    closeDrawer = __webpack_require__(2).closeDrawer,
    BreadCrumbs = __webpack_require__(640),
    closeContextMenu = __webpack_require__(2).closeContextMenu,
    routeResolve = __webpack_require__(33),
    browserHistory = __webpack_require__(40).browserHistory,
    store = __webpack_require__(11);
__webpack_require__(406);

var TopToolBar = React.createClass({
    displayName: 'TopToolBar',

shouldTrigger: false,
    tatsuDestURL: '',
    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        if (this.props.messageBox.get('open') && !nextProps.messageBox.get('open') || !this.props.messageBox.get('open') && nextProps.messageBox.get('open') || this.props.modulePath !== nextProps.modulePath) {
            this.shouldTrigger = true;
        } else {
            this.shouldTrigger = false;
        }
    },
    shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

return this.shouldTrigger;
    },

handleDialogClose: function handleDialogClose(event) {

store.dispatch({ type: 'CLOSE_SNACKBAR', loadState: 1 });
    },

togglePreview: function togglePreview(checked) {

leaveTatsu: function leaveTatsu(action, event) {

var currentState = this.props.currentState,
            lastSavedState = this.props.lastSavedState,
            popUpMeta = '',
            destinationLink = '';

if (action === 'dashboard') {
            popUpMeta = Immutable.Map({
                type: 'save',
                message: 'You will lose your unsaved changes if you navigate away from this page, are you sure you want to do this?'
            });
            this.tatsuDestURL = tatsuConfig.post_dashboard_link;
        } else if (action === 'reload') {
            popUpMeta = Immutable.Map({
                type: 'save',
                message: 'You will lose your unsaved changes if you reload this page, are you sure you want to do this?'
            });
            this.tatsuDestURL = tatsuConfig.page_url;
        }

event.preventDefault();
        if (!Immutable.is(currentState, lastSavedState)) {
            store.dispatch(sendMessage(popUpMeta, 'popUp'));
        } else {
            window.location.href = this.tatsuDestURL;
        }
    },

render: function render() {

return React.createElement(
            'div',
            { className: 'tatsu-top-toolbar-wrapper' },
            React.createElement(
                'div',
                { className: 'tatsu-top-icons-left-wrapper' },
                React.createElement(
                    'div',
                    { className: 'tatsu-topbar-breadcrumbs tatsu-top-toolbar-tool' },
                    React.createElement(BreadCrumbs, { tab: 'topbar', builderMode: this.props.builderMode, path: this.props.modulePath, pageContent: this.props.pageContent, pathFromRoute: this.props.pathFromRoute })
                )
            ),
            React.createElement(
                'div',
                { className: 'tatsu-top-icons-wrapper' },
                React.createElement(
                    'div',
                    { className: 'tatsu-topbar-reload tatsu-top-toolbar-tool', onClick: this.leaveTatsu.bind(null, 'reload') },
                    React.createElement(
                        'div',
                        { className: 'tatsu-topbar-reload-icon' },
                        React.createElement(
                            'svg',
                            { width: '18', height: '18', viewBox: '0 0 24 24' },
                            React.createElement('path', { fill: 'none', d: 'M0 0h24v24H0V0z' }),
                            React.createElement('path', { d: 'M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z' })
                        )
                    ),
                    React.createElement(
                        'div',
                        { className: 'tatsu-topbar-reload-title' },
                        'RELOAD'
                    )
                ),
                React.createElement(
                    'div',
                    { ref: 'preview', className: 'tatsu-top-toolbar-tool tatsu-preview-tool' },
                    React.createElement(
                        'span',
                        { className: 'tatsu-top-tool-text' },
                        'Preview'
                    ),
                    React.createElement(
                        'span',
                        { className: 'be-switch' },
                        React.createElement(_switch2.default, { style: { width: '50%', marginLeft: 10 }, defaultChecked: false, onChange: this.togglePreview })
                    )
                ),
                React.createElement(
                    'div',
                    { onClick: this.leaveTatsu.bind(this, 'dashboard'), className: 'tatsu-top-toolbar-tool tatsu-dashboard-tool' },
                    React.createElement(
                        'div',
                        { className: 'tatsu-top-tool-image' },
                        React.createElement(
                            'svg',
                            { style: { display: "block" }, role: 'img', fillRule: 'evenodd', className: 'tatsu-svg-icon', viewBox: '0 0 5.5555557 5.5555555' },
                            React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-wp-logo' })
                        )
                    ),
                    React.createElement(
                        'span',
                        { className: 'tatsu-top-tool-text' },
                        React.createElement(
                            'a',
                            { href: tatsuConfig.post_dashboard_link },
                            'Dashboard'
                        )
                    )
                ),
                this.props.builderMode === 'page_builder' && React.createElement(
                    'div',
                    { onClick: openInNewTab.bind(null, tatsuConfig.post_permalink), className: 'tatsu-top-toolbar-tool' },
                    React.createElement(
                        'div',
                        { className: 'tatsu-top-tool-image' },
                        '\u2192'
                    ),
                    React.createElement(
                        'span',
                        { className: 'tatsu-top-tool-text' },
                        'View Page'
                    )
                ),
                this.props.builderMode != 'page_builder' && React.createElement(
                    'div',
                    { onClick: openInNewTab.bind(null, tatsuConfig.home_url), className: 'tatsu-top-toolbar-tool' },
                    React.createElement(
                        'div',
                        { className: 'tatsu-top-tool-image' },
                        '\u2192'
                    ),
                    React.createElement(
                        'span',
                        { className: 'tatsu-top-tool-text' },
                        'View Home'
                    )
                )
            ),
            React.createElement(
                _modal2.default,
                {
                    title: 'save' == this.props.messageBox.getIn(['meta', 'type']) ? "There are some unsaved changes!" : "Your browser doesn't support this",
                    visible: this.props.messageBox.get('open') && 'popUp' == this.props.messageBox.get('type'),
                    onOk: 'save' == this.props.messageBox.getIn(['meta', 'type']) ? function () {
                        window.location.href = this.tatsuDestURL;
                    }.bind(this) : this.handleDialogClose,
                    okText: 'save' == this.props.messageBox.getIn(['meta', 'type']) ? "Yes, Proceed" : '',
                    onCancel: this.handleDialogClose,
                    cancelText: 'save' == this.props.messageBox.getIn(['meta', 'type']) ? "No, Stay here" : ''
                },
                this.props.messageBox.getIn(['meta', 'message'])
            )
        );
    }

});
TopToolBar.contextTypes = {

dragDropManager: React.PropTypes.object.isRequired

};
exports.default = TopToolBar;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 236 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

module.exports = function fitVideoToContainer(bgVideoWrap) {

if (bgVideoWrap.length > 0) {
        bgVideoWrap.on("loadedmetadata", function () {

jQuery(this).css({
                width: this.videoWidth,
                height: this.videoHeight
            });
            var $img = jQuery(this),
                $section = $img.parent(),
                windowWidth = $section.width(),
                windowHeight = $section.outerHeight(),
                r_w = windowHeight / windowWidth,
                i_w = $img.width(),
                i_h = $img.height(),
                r_i = i_h / i_w,
                new_w,
                new_h;

if (r_w > r_i) {
                new_h = windowHeight;
                new_w = windowHeight / r_i;
            } else {
                new_h = windowWidth * r_i;
                new_w = windowWidth;
            }
            $img.css({
                width: new_w,
                height: new_h,
                left: (windowWidth - new_w) / 2,
                top: (windowHeight - new_h) / 2,
                display: 'block'
            });
            jQuery(this).css('display', 'block');
        });
    }
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 237 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

function getCSSUnitAndValue(value) {

if (!value || !value.length) {
    return ' ';
  }
  var len = value.length;
  var i = len;
  while (i--) {
    if (!isNaN(value[i])) {
      return {
        value: value.slice(0, i + 1, len),
        unit: value.slice(i + 1, len)
      } || ' ';
    }
  }
  return ' ';
}

module.exports = getCSSUnitAndValue;

/***/ }),
/* 238 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function getDropTargetPath(sourcePath, targetPath) {

var draggedModuleIndex, targetModuleIndex;
    if (sourcePath.size < targetPath.size && Immutable.is(sourcePath.slice(0, -1), targetPath.slice(0, sourcePath.size - 1))) {
        draggedModuleIndex = sourcePath.get(sourcePath.size - 1);
        targetModuleIndex = targetPath.get(sourcePath.size - 1);
        if (draggedModuleIndex < targetModuleIndex) {
            return targetPath.set(sourcePath.size - 1, targetPath.get(sourcePath.size - 1) - 1);
        } else {
            return targetPath;
        }
    } else {
        return targetPath;
    }
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 239 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function getPathFromPosition(path, position, isInterColumn) {

if (!isInterColumn) {
        return path;
    } else {
        if ('top' == position) {
            return path;
        } else if ('' == position) {
            return path.push(0);
        } else if ('bottom' == position) {
            return path.set(path.size - 1, path.get(path.size - 1) + 1);
        }
    }
};

/***/ }),
/* 240 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var isEmpty = __webpack_require__(5);

module.exports = function getSvgIconPath(svgUrl) {
    var svgIconNameFamilyArray = [],
        svgIconFamily = '',
        svgIconName = '';
    if (!isEmpty(svgUrl) && null != tatsuSvgs) {
        svgIconNameFamilyArray = svgUrl.split(":");
        if (0 < svgIconNameFamilyArray.length) {
            svgIconFamily = svgIconNameFamilyArray[0];
            svgIconName = svgIconNameFamilyArray[1];
            if (null != tatsuSvgs[svgIconFamily] && '' != svgIconName) {
                return tatsuSvgs[svgIconFamily].link + svgIconName + '.svg';
            }
        }
    }
    return '';
};

/***/ }),
/* 241 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

module.exports = function scrollToSelectedNode(node, offset) {

var ps;
        if (!(node instanceof currentDocument.defaultView.HTMLElement || node instanceof currentDocument.defaultView.SVGElement)) {
            return;
        }
        ps = parents(node.parentNode, []);
        for (var i = 0; i < ps.length; i += 1) {
            if (scroll(ps[i])) {
                return ps[i];
            }
        }
        return currentDocument.body;
    },
        getScrollDistance = function getScrollDistance(node) {

if (offset && !isNaN(offset)) {
            actualDistance = actualDistance - offset;
        }

jQuery(currentDocument).find('html,body').stop().animate({ scrollTop: actualDistance }, '800', 'swing');
    } else {
        scrollParentDistanceFromTop = getScrollDistance(scrollParent);
        nodeDistanceFromTop = getScrollDistance(node);
        actualDistance = nodeDistanceFromTop - scrollParentDistanceFromTop;
        if ('string' == typeof arguments[2] && 'viewportmid' == arguments[2]) {
            actualDistance = actualDistance + node.getBoundingClientRect().height / 2 - window.innerHeight / 2;
        }
        if (offset && !isNaN(offset)) {
            actualDistance = actualDistance - offset;
        }
        jQuery(currentDocument).find(scrollParent).stop().animate({ scrollTop: actualDistance }, '800', 'swing');
    }
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 242 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function triggerScript(node) {

node.parentNode.replaceChild(nodeScriptClone(node), node);
        } else {
                var i = 0;
                var children = node.childNodes;
                while (i < children.length) {
                        triggerScript(children[i++]);
                }
        }
        return node;
};

/***/ }),
/* 243 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var bind = __webpack_require__(264);
var GetIntrinsic = __webpack_require__(413);

var $apply = GetIntrinsic('%Function.prototype.apply%');
var $call = GetIntrinsic('%Function.prototype.call%');
var $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);

var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
var $max = GetIntrinsic('%Math.max%');

if ($defineProperty) {
	try {
		$defineProperty({}, 'a', { value: 1 });
	} catch (e) {
		// IE 8 has a broken defineProperty
		$defineProperty = null;
	}
}

module.exports = function callBind(originalFunction) {
	var func = $reflectApply(bind, $call, arguments);
	if ($gOPD && $defineProperty) {
		var desc = $gOPD(func, 'length');
		if (desc.configurable) {
			// original length, plus the receiver, minus any additional arguments (after the receiver)
			$defineProperty(
				func,
				'length',
				{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
			);
		}
	}
	return func;
};

var applyBind = function applyBind() {
	return $reflectApply(bind, $apply, arguments);
};

if ($defineProperty) {
	$defineProperty(module.exports, 'apply', { value: applyBind });
} else {
	module.exports.apply = applyBind;
}

/***/ }),
/* 244 */
/***/ (function(module, exports, __webpack_require__) {

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE

// This is CodeMirror (https://codemirror.net), a code editor
// implemented in JavaScript on top of the browser's DOM.
//
// You can find some technical background for some of the code below
// at http://marijnhaverbeke.nl/blog/#cm-internals .

(function (global, factory) {
   true ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global.CodeMirror = factory());
}(this, (function () { 'use strict';

// Kludges for bugs and behavior differences that can't be feature
  // detected are enabled based on userAgent etc sniffing.
  var userAgent = navigator.userAgent;
  var platform = navigator.platform;

var gecko = /gecko\/\d/i.test(userAgent);
  var ie_upto10 = /MSIE \d/.test(userAgent);
  var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent);
  var edge = /Edge\/(\d+)/.exec(userAgent);
  var ie = ie_upto10 || ie_11up || edge;
  var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]);
  var webkit = !edge && /WebKit\//.test(userAgent);
  var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent);
  var chrome = !edge && /Chrome\//.test(userAgent);
  var presto = /Opera\//.test(userAgent);
  var safari = /Apple Computer/.test(navigator.vendor);
  var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent);
  var phantom = /PhantomJS/.test(userAgent);

var ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent);
  var android = /Android/.test(userAgent);
  // This is woefully incomplete. Suggestions for alternative methods welcome.
  var mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent);
  var mac = ios || /Mac/.test(platform);
  var chromeOS = /\bCrOS\b/.test(userAgent);
  var windows = /win/i.test(platform);

var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/);
  if (presto_version) { presto_version = Number(presto_version[1]); }
  if (presto_version && presto_version >= 15) { presto = false; webkit = true; }
  // Some browsers use the wrong event properties to signal cmd/ctrl on OS X
  var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11));
  var captureRightClick = gecko || (ie && ie_version >= 9);

function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") }

var rmClass = function(node, cls) {
    var current = node.className;
    var match = classTest(cls).exec(current);
    if (match) {
      var after = current.slice(match.index + match[0].length);
      node.className = current.slice(0, match.index) + (after ? match[1] + after : "");
    }
  };

function removeChildren(e) {
    for (var count = e.childNodes.length; count > 0; --count)
      { e.removeChild(e.firstChild); }
    return e
  }

function removeChildrenAndAdd(parent, e) {
    return removeChildren(parent).appendChild(e)
  }

var range;
  if (document.createRange) { range = function(node, start, end, endNode) {
    var r = document.createRange();
    r.setEnd(endNode || node, end);
    r.setStart(node, start);
    return r
  }; }
  else { range = function(node, start, end) {
    var r = document.body.createTextRange();
    try { r.moveToElementText(node.parentNode); }
    catch(e) { return r }
    r.collapse(true);
    r.moveEnd("character", end);
    r.moveStart("character", start);
    return r
  }; }

function contains(parent, child) {
    if (child.nodeType == 3) // Android browser always returns false when child is a textnode
      { child = child.parentNode; }
    if (parent.contains)
      { return parent.contains(child) }
    do {
      if (child.nodeType == 11) { child = child.host; }
      if (child == parent) { return true }
    } while (child = child.parentNode)
  }

function bind(f) {
    var args = Array.prototype.slice.call(arguments, 1);
    return function(){return f.apply(null, args)}
  }

function copyObj(obj, target, overwrite) {
    if (!target) { target = {}; }
    for (var prop in obj)
      { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
        { target[prop] = obj[prop]; } }
    return target
  }

// Counts the column offset in a string, taking tabs into account.
  // Used mostly to find indentation.
  function countColumn(string, end, tabSize, startIndex, startValue) {
    if (end == null) {
      end = string.search(/[^\s\u00a0]/);
      if (end == -1) { end = string.length; }
    }
    for (var i = startIndex || 0, n = startValue || 0;;) {
      var nextTab = string.indexOf("\t", i);
      if (nextTab < 0 || nextTab >= end)
        { return n + (end - i) }
      n += nextTab - i;
      n += tabSize - (n % tabSize);
      i = nextTab + 1;
    }
  }

var Delayed = function() {this.id = null;};
  Delayed.prototype.set = function (ms, f) {
    clearTimeout(this.id);
    this.id = setTimeout(f, ms);
  };

function indexOf(array, elt) {
    for (var i = 0; i < array.length; ++i)
      { if (array[i] == elt) { return i } }
    return -1
  }

// Number of pixels added to scroller and sizer to hide scrollbar
  var scrollerGap = 30;

// Returned or thrown by various protocols to signal 'I'm not
  // handling this'.
  var Pass = {toString: function(){return "CodeMirror.Pass"}};

// Reused option objects for setSelection & friends
  var sel_dontScroll = {scroll: false}, sel_mouse = {origin: "*mouse"}, sel_move = {origin: "+move"};

// The inverse of countColumn -- find the offset that corresponds to
  // a particular column.
  function findColumn(string, goal, tabSize) {
    for (var pos = 0, col = 0;;) {
      var nextTab = string.indexOf("\t", pos);
      if (nextTab == -1) { nextTab = string.length; }
      var skipped = nextTab - pos;
      if (nextTab == string.length || col + skipped >= goal)
        { return pos + Math.min(skipped, goal - col) }
      col += nextTab - pos;
      col += tabSize - (col % tabSize);
      pos = nextTab + 1;
      if (col >= goal) { return pos }
    }
  }

var spaceStrs = [""];
  function spaceStr(n) {
    while (spaceStrs.length <= n)
      { spaceStrs.push(lst(spaceStrs) + " "); }
    return spaceStrs[n]
  }

function lst(arr) { return arr[arr.length-1] }

function map(array, f) {
    var out = [];
    for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i); }
    return out
  }

function insertSorted(array, value, score) {
    var pos = 0, priority = score(value);
    while (pos < array.length && score(array[pos]) <= priority) { pos++; }
    array.splice(pos, 0, value);
  }

function nothing() {}

var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
  function isWordCharBasic(ch) {
    return /\w/.test(ch) || ch > "\x80" &&
      (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))
  }
  function isWordChar(ch, helper) {
    if (!helper) { return isWordCharBasic(ch) }
    if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) { return true }
    return helper.test(ch)
  }

function isEmpty(obj) {
    for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }
    return true
  }

// Extending unicode characters. A series of a non-extending char +
  // any number of extending chars is treated as a single unit as far
  // as editing and measuring is concerned. This is not fully correct,
  // since some scripts/fonts/browsers also treat other configurations
  // of code points as a group.
  var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/;
  function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }

// Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.
  function skipExtendingChars(str, pos, dir) {
    while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir; }
    return pos
  }

// Returns the value from the range [`from`; `to`] that satisfies
  // `pred` and is closest to `from`. Assumes that at least `to`
  // satisfies `pred`. Supports `from` being greater than `to`.
  function findFirst(pred, from, to) {
    // At any point we are certain `to` satisfies `pred`, don't know
    // whether `from` does.
    var dir = from > to ? -1 : 1;
    for (;;) {
      if (from == to) { return from }
      var midF = (from + to) / 2, mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF);
      if (mid == from) { return pred(mid) ? from : to }
      if (pred(mid)) { to = mid; }
      else { from = mid + dir; }
    }
  }

// The display handles the DOM integration, both for input reading
  // and content drawing. It holds references to DOM nodes and
  // display-related state.

function Display(place, doc, input) {
    var d = this;
    this.input = input;

// Covers bottom-right square when both scrollbars are present.
    d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler");
    d.scrollbarFiller.setAttribute("cm-not-content", "true");
    // Covers bottom of gutter when coverGutterNextToScrollbar is on
    // and h scrollbar is present.
    d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler");
    d.gutterFiller.setAttribute("cm-not-content", "true");
    // Will contain the actual code, positioned to cover the viewport.
    d.lineDiv = eltP("div", null, "CodeMirror-code");
    // Elements are added to these to represent selection and cursors.
    d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1");
    d.cursorDiv = elt("div", null, "CodeMirror-cursors");
    // A visibility: hidden element used to find the size of things.
    d.measure = elt("div", null, "CodeMirror-measure");
    // When lines outside of the viewport are measured, they are drawn in this.
    d.lineMeasure = elt("div", null, "CodeMirror-measure");
    // Wraps everything that needs to exist inside the vertically-padded coordinate system
    d.lineSpace = eltP("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],
                      null, "position: relative; outline: none");
    var lines = eltP("div", [d.lineSpace], "CodeMirror-lines");
    // Moved around its parent to cover visible view.
    d.mover = elt("div", [lines], null, "position: relative");
    // Set to the height of the document, allowing scrolling.
    d.sizer = elt("div", [d.mover], "CodeMirror-sizer");
    d.sizerWidth = null;
    // Behavior of elts with overflow: auto and padding is
    // inconsistent across browsers. This is used to ensure the
    // scrollable area is big enough.
    d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;");
    // Will contain the gutters, if any.
    d.gutters = elt("div", null, "CodeMirror-gutters");
    d.lineGutter = null;
    // Actual scrollable element.
    d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll");
    d.scroller.setAttribute("tabIndex", "-1");
    // The element in which the editor lives.
    d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror");

// Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)
    if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }
    if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true; }

if (place) {
      if (place.appendChild) { place.appendChild(d.wrapper); }
      else { place(d.wrapper); }
    }

// Current rendered range (may be bigger than the view window).
    d.viewFrom = d.viewTo = doc.first;
    d.reportedViewFrom = d.reportedViewTo = doc.first;
    // Information about the rendered lines.
    d.view = [];
    d.renderedView = null;
    // Holds info about a single rendered line when it was rendered
    // for measurement, while not in view.
    d.externalMeasured = null;
    // Empty space (in pixels) above the view
    d.viewOffset = 0;
    d.lastWrapHeight = d.lastWrapWidth = 0;
    d.updateLineNumbers = null;

d.nativeBarWidth = d.barHeight = d.barWidth = 0;
    d.scrollbarsClipped = false;

// Used to only resize the line number gutter when necessary (when
    // the amount of lines crosses a boundary that makes its width change)
    d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;
    // Set to true when a non-horizontal-scrolling line widget is
    // added. As an optimization, line widget aligning is skipped when
    // this is false.
    d.alignWidgets = false;

d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;

// Tracks the maximum line length so that the horizontal scrollbar
    // can be kept static when scrolling.
    d.maxLine = null;
    d.maxLineLength = 0;
    d.maxLineChanged = false;

// Used for measuring wheel scrolling granularity
    d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null;

// True when shift is held down.
    d.shift = false;

// Used to track whether anything happened since the context menu
    // was opened.
    d.selForContextMenu = null;

d.activeTouch = null;

input.init(d);
  }

// Find the line object corresponding to the given line number.
  function getLine(doc, n) {
    n -= doc.first;
    if (n < 0 || n >= doc.size) { throw new Error("There is no line " + (n + doc.first) + " in the document.") }
    var chunk = doc;
    while (!chunk.lines) {
      for (var i = 0;; ++i) {
        var child = chunk.children[i], sz = child.chunkSize();
        if (n < sz) { chunk = child; break }
        n -= sz;
      }
    }
    return chunk.lines[n]
  }

// Get the part of a document between two positions, as an array of
  // strings.
  function getBetween(doc, start, end) {
    var out = [], n = start.line;
    doc.iter(start.line, end.line + 1, function (line) {
      var text = line.text;
      if (n == end.line) { text = text.slice(0, end.ch); }
      if (n == start.line) { text = text.slice(start.ch); }
      out.push(text);
      ++n;
    });
    return out
  }
  // Get the lines between from and to, as array of strings.
  function getLines(doc, from, to) {
    var out = [];
    doc.iter(from, to, function (line) { out.push(line.text); }); // iter aborts when callback returns truthy value
    return out
  }

// Update the height of a line, propagating the height change
  // upwards to parent nodes.
  function updateLineHeight(line, height) {
    var diff = height - line.height;
    if (diff) { for (var n = line; n; n = n.parent) { n.height += diff; } }
  }

// Given a line object, find its line number by walking up through
  // its parent links.
  function lineNo(line) {
    if (line.parent == null) { return null }
    var cur = line.parent, no = indexOf(cur.lines, line);
    for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
      for (var i = 0;; ++i) {
        if (chunk.children[i] == cur) { break }
        no += chunk.children[i].chunkSize();
      }
    }
    return no + cur.first
  }

// Find the line at the given vertical position, using the height
  // information in the document tree.
  function lineAtHeight(chunk, h) {
    var n = chunk.first;
    outer: do {
      for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {
        var child = chunk.children[i$1], ch = child.height;
        if (h < ch) { chunk = child; continue outer }
        h -= ch;
        n += child.chunkSize();
      }
      return n
    } while (!chunk.lines)
    var i = 0;
    for (; i < chunk.lines.length; ++i) {
      var line = chunk.lines[i], lh = line.height;
      if (h < lh) { break }
      h -= lh;
    }
    return n + i
  }

function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}

function lineNumberFor(options, i) {
    return String(options.lineNumberFormatter(i + options.firstLineNumber))
  }

// A Pos instance represents a position within the text.
  function Pos(line, ch, sticky) {
    if ( sticky === void 0 ) sticky = null;

if (!(this instanceof Pos)) { return new Pos(line, ch, sticky) }
    this.line = line;
    this.ch = ch;
    this.sticky = sticky;
  }

// Compare two positions, return 0 if they are the same, a negative
  // number when a is less, and a positive number otherwise.
  function cmp(a, b) { return a.line - b.line || a.ch - b.ch }

function equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 }

function copyPos(x) {return Pos(x.line, x.ch)}
  function maxPos(a, b) { return cmp(a, b) < 0 ? b : a }
  function minPos(a, b) { return cmp(a, b) < 0 ? a : b }

// Most of the external API clips given positions to make sure they
  // actually exist within the document.
  function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}
  function clipPos(doc, pos) {
    if (pos.line < doc.first) { return Pos(doc.first, 0) }
    var last = doc.first + doc.size - 1;
    if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }
    return clipToLen(pos, getLine(doc, pos.line).text.length)
  }
  function clipToLen(pos, linelen) {
    var ch = pos.ch;
    if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }
    else if (ch < 0) { return Pos(pos.line, 0) }
    else { return pos }
  }
  function clipPosArray(doc, array) {
    var out = [];
    for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]); }
    return out
  }

// Optimize some code when these features are not used.
  var sawReadOnlySpans = false, sawCollapsedSpans = false;

function seeReadOnlySpans() {
    sawReadOnlySpans = true;
  }

function seeCollapsedSpans() {
    sawCollapsedSpans = true;
  }

// TEXTMARKER SPANS

function MarkedSpan(marker, from, to) {
    this.marker = marker;
    this.from = from; this.to = to;
  }

// Search an array of spans for a span matching the given marker.
  function getMarkedSpanFor(spans, marker) {
    if (spans) { for (var i = 0; i < spans.length; ++i) {
      var span = spans[i];
      if (span.marker == marker) { return span }
    } }
  }
  // Remove a span from an array, returning undefined if no spans are
  // left (we don't store arrays for lines without spans).
  function removeMarkedSpan(spans, span) {
    var r;
    for (var i = 0; i < spans.length; ++i)
      { if (spans[i] != span) { (r || (r = [])).push(spans[i]); } }
    return r
  }
  // Add a span to a line.
  function addMarkedSpan(line, span) {
    line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span];
    span.marker.attachLine(line);
  }

// Used for the algorithm that adjusts markers for a change in the
  // document. These functions cut an array of spans at a given
  // character position, returning an array of remaining chunks (or
  // undefined if nothing remains).
  function markedSpansBefore(old, startCh, isInsert) {
    var nw;
    if (old) { for (var i = 0; i < old.length; ++i) {
      var span = old[i], marker = span.marker;
      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh);
      if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {
        var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh)
        ;(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to));
      }
    } }
    return nw
  }
  function markedSpansAfter(old, endCh, isInsert) {
    var nw;
    if (old) { for (var i = 0; i < old.length; ++i) {
      var span = old[i], marker = span.marker;
      var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh);
      if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {
        var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh)
        ;(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,
                                              span.to == null ? null : span.to - endCh));
      }
    } }
    return nw
  }

// Given a change object, compute the new set of marker spans that
  // cover the line in which the change took place. Removes spans
  // entirely within the change, reconnects spans belonging to the
  // same marker that appear on both sides of the change, and cuts off
  // spans partially within the change. Returns an array of span
  // arrays with one element for each line in (after) the change.
  function stretchSpansOverChange(doc, change) {
    if (change.full) { return null }
    var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans;
    var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans;
    if (!oldFirst && !oldLast) { return null }

var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0;
    // Get the spans that 'stick out' on both sides
    var first = markedSpansBefore(oldFirst, startCh, isInsert);
    var last = markedSpansAfter(oldLast, endCh, isInsert);

// Next, merge those two ends
    var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0);
    if (first) {
      // Fix up .to properties of first
      for (var i = 0; i < first.length; ++i) {
        var span = first[i];
        if (span.to == null) {
          var found = getMarkedSpanFor(last, span.marker);
          if (!found) { span.to = startCh; }
          else if (sameLine) { span.to = found.to == null ? null : found.to + offset; }
        }
      }
    }
    if (last) {
      // Fix up .from in last (or move them into first in case of sameLine)
      for (var i$1 = 0; i$1 < last.length; ++i$1) {
        var span$1 = last[i$1];
        if (span$1.to != null) { span$1.to += offset; }
        if (span$1.from == null) {
          var found$1 = getMarkedSpanFor(first, span$1.marker);
          if (!found$1) {
            span$1.from = offset;
            if (sameLine) { (first || (first = [])).push(span$1); }
          }
        } else {
          span$1.from += offset;
          if (sameLine) { (first || (first = [])).push(span$1); }
        }
      }
    }
    // Make sure we didn't create any zero-length spans
    if (first) { first = clearEmptySpans(first); }
    if (last && last != first) { last = clearEmptySpans(last); }

// Remove spans that are empty and don't have a clearWhenEmpty
  // option of false.
  function clearEmptySpans(spans) {
    for (var i = 0; i < spans.length; ++i) {
      var span = spans[i];
      if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)
        { spans.splice(i--, 1); }
    }
    if (!spans.length) { return null }
    return spans
  }

// Used to 'clip' out readOnly ranges when making a change.
  function removeReadOnlyRanges(doc, from, to) {
    var markers = null;
    doc.iter(from.line, to.line + 1, function (line) {
      if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {
        var mark = line.markedSpans[i].marker;
        if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))
          { (markers || (markers = [])).push(mark); }
      } }
    });
    if (!markers) { return null }
    var parts = [{from: from, to: to}];
    for (var i = 0; i < markers.length; ++i) {
      var mk = markers[i], m = mk.find(0);
      for (var j = 0; j < parts.length; ++j) {
        var p = parts[j];
        if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }
        var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to);
        if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)
          { newParts.push({from: p.from, to: m.from}); }
        if (dto > 0 || !mk.inclusiveRight && !dto)
          { newParts.push({from: m.to, to: p.to}); }
        parts.splice.apply(parts, newParts);
        j += newParts.length - 3;
      }
    }
    return parts
  }

// Connect or disconnect spans from a line.
  function detachMarkedSpans(line) {
    var spans = line.markedSpans;
    if (!spans) { return }
    for (var i = 0; i < spans.length; ++i)
      { spans[i].marker.detachLine(line); }
    line.markedSpans = null;
  }
  function attachMarkedSpans(line, spans) {
    if (!spans) { return }
    for (var i = 0; i < spans.length; ++i)
      { spans[i].marker.attachLine(line); }
    line.markedSpans = spans;
  }

// Helpers used when computing which overlapping collapsed span
  // counts as the larger one.
  function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }
  function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }

// Returns a number indicating which of two overlapping collapsed
  // spans is larger (and thus includes the other). Falls back to
  // comparing ids when the spans cover exactly the same range.
  function compareCollapsedMarkers(a, b) {
    var lenDiff = a.lines.length - b.lines.length;
    if (lenDiff != 0) { return lenDiff }
    var aPos = a.find(), bPos = b.find();
    var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b);
    if (fromCmp) { return -fromCmp }
    var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b);
    if (toCmp) { return toCmp }
    return b.id - a.id
  }

// Find out whether a line ends or starts in a collapsed span. If
  // so, return the marker for that span.
  function collapsedSpanAtSide(line, start) {
    var sps = sawCollapsedSpans && line.markedSpans, found;
    if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
      sp = sps[i];
      if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&
          (!found || compareCollapsedMarkers(found, sp.marker) < 0))
        { found = sp.marker; }
    } }
    return found
  }
  function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }
  function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }

// Test whether there exists a collapsed span that partially
  // overlaps (covers the start or end, but not both) of a new span.
  // Such overlap is not allowed.
  function conflictingCollapsedRange(doc, lineNo$$1, from, to, marker) {
    var line = getLine(doc, lineNo$$1);
    var sps = sawCollapsedSpans && line.markedSpans;
    if (sps) { for (var i = 0; i < sps.length; ++i) {
      var sp = sps[i];
      if (!sp.marker.collapsed) { continue }
      var found = sp.marker.find(0);
      var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker);
      var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker);
      if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }
      if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||
          fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))
        { return true }
    } }
  }

// A visual line is a line as drawn on the screen. Folding, for
  // example, can cause multiple logical lines to appear on the same
  // visual line. This finds the start of the visual line that the
  // given line is part of (usually that is the line itself).
  function visualLine(line) {
    var merged;
    while (merged = collapsedSpanAtStart(line))
      { line = merged.find(-1, true).line; }
    return line
  }

function visualLineEnd(line) {
    var merged;
    while (merged = collapsedSpanAtEnd(line))
      { line = merged.find(1, true).line; }
    return line
  }

// Returns an array of logical lines that continue the visual line
  // started by the argument, or undefined if there are no such lines.
  function visualLineContinued(line) {
    var merged, lines;
    while (merged = collapsedSpanAtEnd(line)) {
      line = merged.find(1, true).line
      ;(lines || (lines = [])).push(line);
    }
    return lines
  }

// Get the line number of the start of the visual line that the
  // given line number is part of.
  function visualLineNo(doc, lineN) {
    var line = getLine(doc, lineN), vis = visualLine(line);
    if (line == vis) { return lineN }
    return lineNo(vis)
  }

// Get the line number of the start of the next visual line after
  // the given line.
  function visualLineEndNo(doc, lineN) {
    if (lineN > doc.lastLine()) { return lineN }
    var line = getLine(doc, lineN), merged;
    if (!lineIsHidden(doc, line)) { return lineN }
    while (merged = collapsedSpanAtEnd(line))
      { line = merged.find(1, true).line; }
    return lineNo(line) + 1
  }

// Compute whether a line is hidden. Lines count as hidden when they
  // are part of a visual line that starts with another line, or when
  // they are entirely covered by collapsed, non-widget span.
  function lineIsHidden(doc, line) {
    var sps = sawCollapsedSpans && line.markedSpans;
    if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
      sp = sps[i];
      if (!sp.marker.collapsed) { continue }
      if (sp.from == null) { return true }
      if (sp.marker.widgetNode) { continue }
      if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))
        { return true }
    } }
  }
  function lineIsHiddenInner(doc, line, span) {
    if (span.to == null) {
      var end = span.marker.find(1, true);
      return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))
    }
    if (span.marker.inclusiveRight && span.to == line.text.length)
      { return true }
    for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {
      sp = line.markedSpans[i];
      if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&
          (sp.to == null || sp.to != span.from) &&
          (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
          lineIsHiddenInner(doc, line, sp)) { return true }
    }
  }

// Find the height above the given line.
  function heightAtLine(lineObj) {
    lineObj = visualLine(lineObj);

// Compute the character length of a line, taking into account
  // collapsed ranges (see markText) that might hide parts, and join
  // other lines onto it.
  function lineLength(line) {
    if (line.height == 0) { return 0 }
    var len = line.text.length, merged, cur = line;
    while (merged = collapsedSpanAtStart(cur)) {
      var found = merged.find(0, true);
      cur = found.from.line;
      len += found.from.ch - found.to.ch;
    }
    cur = line;
    while (merged = collapsedSpanAtEnd(cur)) {
      var found$1 = merged.find(0, true);
      len -= cur.text.length - found$1.from.ch;
      cur = found$1.to.line;
      len += cur.text.length - found$1.to.ch;
    }
    return len
  }

// Find the longest line in the document.
  function findMaxLine(cm) {
    var d = cm.display, doc = cm.doc;
    d.maxLine = getLine(doc, doc.first);
    d.maxLineLength = lineLength(d.maxLine);
    d.maxLineChanged = true;
    doc.iter(function (line) {
      var len = lineLength(line);
      if (len > d.maxLineLength) {
        d.maxLineLength = len;
        d.maxLine = line;
      }
    });
  }

// BIDI HELPERS

// Bidirectional ordering algorithm
  // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
  // that this (partially) implements.

// One-char codes used for character types:
  // L (L):   Left-to-Right
  // R (R):   Right-to-Left
  // r (AL):  Right-to-Left Arabic
  // 1 (EN):  European Number
  // + (ES):  European Number Separator
  // % (ET):  European Number Terminator
  // n (AN):  Arabic Number
  // , (CS):  Common Number Separator
  // m (NSM): Non-Spacing Mark
  // b (BN):  Boundary Neutral
  // s (B):   Paragraph Separator
  // t (S):   Segment Separator
  // w (WS):  Whitespace
  // N (ON):  Other Neutrals

// Returns null if characters are ordered as they appear
  // (left-to-right), or an array of sections ({from, to, level}
  // objects) in the order in which they occur visually.
  var bidiOrdering = (function() {
    // Character types for codepoints 0 to 0xff
    var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN";
    // Character types for codepoints 0x600 to 0x6f9
    var arabicTypes = "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111";
    function charType(code) {
      if (code <= 0xf7) { return lowTypes.charAt(code) }
      else if (0x590 <= code && code <= 0x5f4) { return "R" }
      else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) }
      else if (0x6ee <= code && code <= 0x8ac) { return "r" }
      else if (0x2000 <= code && code <= 0x200b) { return "w" }
      else if (code == 0x200c) { return "b" }
      else { return "L" }
    }

var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;
    var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/;

function BidiSpan(level, from, to) {
      this.level = level;
      this.from = from; this.to = to;
    }

return function(str, direction) {
      var outerType = direction == "ltr" ? "L" : "R";

if (str.length == 0 || direction == "ltr" && !bidiRE.test(str)) { return false }
      var len = str.length, types = [];
      for (var i = 0; i < len; ++i)
        { types.push(charType(str.charCodeAt(i))); }

// W1. Examine each non-spacing mark (NSM) in the level run, and
      // change the type of the NSM to the type of the previous
      // character. If the NSM is at the start of the level run, it will
      // get the type of sor.
      for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {
        var type = types[i$1];
        if (type == "m") { types[i$1] = prev; }
        else { prev = type; }
      }

// W2. Search backwards from each instance of a European number
      // until the first strong type (R, L, AL, or sor) is found. If an
      // AL is found, change the type of the European number to Arabic
      // number.
      // W3. Change all ALs to R.
      for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {
        var type$1 = types[i$2];
        if (type$1 == "1" && cur == "r") { types[i$2] = "n"; }
        else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R"; } }
      }

// W4. A single European separator between two European numbers
      // changes to a European number. A single common separator between
      // two numbers of the same type changes to that type.
      for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {
        var type$2 = types[i$3];
        if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1"; }
        else if (type$2 == "," && prev$1 == types[i$3+1] &&
                 (prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1; }
        prev$1 = type$2;
      }

// W5. A sequence of European terminators adjacent to European
      // numbers changes to all European numbers.
      // W6. Otherwise, separators and terminators change to Other
      // Neutral.
      for (var i$4 = 0; i$4 < len; ++i$4) {
        var type$3 = types[i$4];
        if (type$3 == ",") { types[i$4] = "N"; }
        else if (type$3 == "%") {
          var end = (void 0);
          for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {}
          var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N";
          for (var j = i$4; j < end; ++j) { types[j] = replace; }
          i$4 = end - 1;
        }
      }

// W7. Search backwards from each instance of a European number
      // until the first strong type (R, L, or sor) is found. If an L is
      // found, then change the type of the European number to L.
      for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {
        var type$4 = types[i$5];
        if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L"; }
        else if (isStrong.test(type$4)) { cur$1 = type$4; }
      }

// N1. A sequence of neutrals takes the direction of the
      // surrounding strong text if the text on both sides has the same
      // direction. European and Arabic numbers act as if they were R in
      // terms of their influence on neutrals. Start-of-level-run (sor)
      // and end-of-level-run (eor) are used at level run boundaries.
      // N2. Any remaining neutrals take the embedding direction.
      for (var i$6 = 0; i$6 < len; ++i$6) {
        if (isNeutral.test(types[i$6])) {
          var end$1 = (void 0);
          for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}
          var before = (i$6 ? types[i$6-1] : outerType) == "L";
          var after = (end$1 < len ? types[end$1] : outerType) == "L";
          var replace$1 = before == after ? (before ? "L" : "R") : outerType;
          for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1; }
          i$6 = end$1 - 1;
        }
      }

// Here we depart from the documented algorithm, in order to avoid
      // building up an actual levels array. Since there are only three
      // levels (0, 1, 2) in an implementation that doesn't take
      // explicit embedding into account, we can build up the order on
      // the fly, without following the level-based algorithm.
      var order = [], m;
      for (var i$7 = 0; i$7 < len;) {
        if (countsAsLeft.test(types[i$7])) {
          var start = i$7;
          for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}
          order.push(new BidiSpan(0, start, i$7));
        } else {
          var pos = i$7, at = order.length;
          for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {}
          for (var j$2 = pos; j$2 < i$7;) {
            if (countsAsNum.test(types[j$2])) {
              if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)); }
              var nstart = j$2;
              for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}
              order.splice(at, 0, new BidiSpan(2, nstart, j$2));
              pos = j$2;
            } else { ++j$2; }
          }
          if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)); }
        }
      }
      if (direction == "ltr") {
        if (order[0].level == 1 && (m = str.match(/^\s+/))) {
          order[0].from = m[0].length;
          order.unshift(new BidiSpan(0, 0, m[0].length));
        }
        if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
          lst(order).to -= m[0].length;
          order.push(new BidiSpan(0, len - m[0].length, len));
        }
      }

return direction == "rtl" ? order.reverse() : order
    }
  })();

// Get the bidi ordering for the given line (and cache it). Returns
  // false for lines that are fully left-to-right, and an array of
  // BidiSpan objects otherwise.
  function getOrder(line, direction) {
    var order = line.order;
    if (order == null) { order = line.order = bidiOrdering(line.text, direction); }
    return order
  }

// EVENT HANDLING

// Lightweight event framework. on/off also work on DOM nodes,
  // registering native DOM handlers.

var noHandlers = [];

function getHandlers(emitter, type) {
    return emitter._handlers && emitter._handlers[type] || noHandlers
  }

// The DOM events that CodeMirror handles can be overridden by
  // registering a (non-DOM) handler on the editor for the event name,
  // and preventDefault-ing the event in that handler.
  function signalDOMEvent(cm, e, override) {
    if (typeof e == "string")
      { e = {type: e, preventDefault: function() { this.defaultPrevented = true; }}; }
    signal(cm, override || e.type, cm, e);
    return e_defaultPrevented(e) || e.codemirrorIgnore
  }

function hasHandler(emitter, type) {
    return getHandlers(emitter, type).length > 0
  }

// Add on and off methods to a constructor's prototype, to make
  // registering events on such objects more convenient.
  function eventMixin(ctor) {
    ctor.prototype.on = function(type, f) {on(this, type, f);};
    ctor.prototype.off = function(type, f) {off(this, type, f);};
  }

// Due to the fact that we still support jurassic IE versions, some
  // compatibility wrappers are needed.

// Detect drag-and-drop
  var dragAndDrop = function() {
    // There is *some* kind of drag-and-drop support in IE6-8, but I
    // couldn't get it to work yet.
    if (ie && ie_version < 9) { return false }
    var div = elt('div');
    return "draggable" in div || "dragDrop" in div
  }();

var zwspSupported;
  function zeroWidthElement(measure) {
    if (zwspSupported == null) {
      var test = elt("span", "\u200b");
      removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]));
      if (measure.firstChild.offsetHeight != 0)
        { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8); }
    }
    var node = zwspSupported ? elt("span", "\u200b") :
      elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px");
    node.setAttribute("cm-text", "");
    return node
  }

// Feature-detect IE's crummy client rect reporting for bidi text
  var badBidiRects;
  function hasBadBidiRects(measure) {
    if (badBidiRects != null) { return badBidiRects }
    var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"));
    var r0 = range(txt, 0, 1).getBoundingClientRect();
    var r1 = range(txt, 1, 2).getBoundingClientRect();
    removeChildren(measure);
    if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)
    return badBidiRects = (r1.right - r0.right < 3)
  }

// See if "".split is the broken IE version, if so, provide an
  // alternative way to split lines.
  var splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? function (string) {
    var pos = 0, result = [], l = string.length;
    while (pos <= l) {
      var nl = string.indexOf("\n", pos);
      if (nl == -1) { nl = string.length; }
      var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl);
      var rt = line.indexOf("\r");
      if (rt != -1) {
        result.push(line.slice(0, rt));
        pos += rt + 1;
      } else {
        result.push(line);
        pos = nl + 1;
      }
    }
    return result
  } : function (string) { return string.split(/\r\n?|\n/); };

var hasCopyEvent = (function () {
    var e = elt("div");
    if ("oncopy" in e) { return true }
    e.setAttribute("oncopy", "return;");
    return typeof e.oncopy == "function"
  })();

var badZoomedRects = null;
  function hasBadZoomedRects(measure) {
    if (badZoomedRects != null) { return badZoomedRects }
    var node = removeChildrenAndAdd(measure, elt("span", "x"));
    var normal = node.getBoundingClientRect();
    var fromRange = range(node, 0, 1).getBoundingClientRect();
    return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1
  }

// Known modes, by name and by MIME
  var modes = {}, mimeModes = {};

// Extra arguments are stored as the mode's dependencies, which is
  // used by (legacy) mechanisms like loadmode.js to automatically
  // load a mode. (Preferred mechanism is the require/define calls.)
  function defineMode(name, mode) {
    if (arguments.length > 2)
      { mode.dependencies = Array.prototype.slice.call(arguments, 2); }
    modes[name] = mode;
  }

function defineMIME(mime, spec) {
    mimeModes[mime] = spec;
  }

// Given a MIME type, a {name, ...options} config object, or a name
  // string, return a mode config object.
  function resolveMode(spec) {
    if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
      spec = mimeModes[spec];
    } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
      var found = mimeModes[spec.name];
      if (typeof found == "string") { found = {name: found}; }
      spec = createObj(found, spec);
      spec.name = found.name;
    } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
      return resolveMode("application/xml")
    } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) {
      return resolveMode("application/json")
    }
    if (typeof spec == "string") { return {name: spec} }
    else { return spec || {name: "null"} }
  }

// Given a mode spec (anything that resolveMode accepts), find and
  // initialize an actual mode object.
  function getMode(options, spec) {
    spec = resolveMode(spec);
    var mfactory = modes[spec.name];
    if (!mfactory) { return getMode(options, "text/plain") }
    var modeObj = mfactory(options, spec);
    if (modeExtensions.hasOwnProperty(spec.name)) {
      var exts = modeExtensions[spec.name];
      for (var prop in exts) {
        if (!exts.hasOwnProperty(prop)) { continue }
        if (modeObj.hasOwnProperty(prop)) { modeObj["_" + prop] = modeObj[prop]; }
        modeObj[prop] = exts[prop];
      }
    }
    modeObj.name = spec.name;
    if (spec.helperType) { modeObj.helperType = spec.helperType; }
    if (spec.modeProps) { for (var prop$1 in spec.modeProps)
      { modeObj[prop$1] = spec.modeProps[prop$1]; } }

return modeObj
  }

// This can be used to attach properties to mode objects from
  // outside the actual mode definition.
  var modeExtensions = {};
  function extendMode(mode, properties) {
    var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});
    copyObj(properties, exts);
  }

// Given a mode and a state (for that mode), find the inner mode and
  // state at the position that the state refers to.
  function innerMode(mode, state) {
    var info;
    while (mode.innerMode) {
      info = mode.innerMode(state);
      if (!info || info.mode == mode) { break }
      state = info.state;
      mode = info.mode;
    }
    return info || {mode: mode, state: state}
  }

function startState(mode, a1, a2) {
    return mode.startState ? mode.startState(a1, a2) : true
  }

// STRING STREAM

// Fed to the mode parsers, provides helper functions to make
  // parsers more succinct.

var StringStream = function(string, tabSize, lineOracle) {
    this.pos = this.start = 0;
    this.string = string;
    this.tabSize = tabSize || 8;
    this.lastColumnPos = this.lastColumnValue = 0;
    this.lineStart = 0;
    this.lineOracle = lineOracle;
  };

StringStream.prototype.eol = function () {return this.pos >= this.string.length};
  StringStream.prototype.sol = function () {return this.pos == this.lineStart};
  StringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined};
  StringStream.prototype.next = function () {
    if (this.pos < this.string.length)
      { return this.string.charAt(this.pos++) }
  };
  StringStream.prototype.eat = function (match) {
    var ch = this.string.charAt(this.pos);
    var ok;
    if (typeof match == "string") { ok = ch == match; }
    else { ok = ch && (match.test ? match.test(ch) : match(ch)); }
    if (ok) {++this.pos; return ch}
  };
  StringStream.prototype.eatWhile = function (match) {
    var start = this.pos;
    while (this.eat(match)){}
    return this.pos > start
  };
  StringStream.prototype.eatSpace = function () {
      var this$1 = this;

var SavedContext = function(state, lookAhead) {
    this.state = state;
    this.lookAhead = lookAhead;
  };

var Context = function(doc, state, line, lookAhead) {
    this.state = state;
    this.doc = doc;
    this.line = line;
    this.maxLookAhead = lookAhead || 0;
    this.baseTokens = null;
    this.baseTokenPos = 1;
  };

Context.prototype.lookAhead = function (n) {
    var line = this.doc.getLine(this.line + n);
    if (line != null && n > this.maxLookAhead) { this.maxLookAhead = n; }
    return line
  };

Context.prototype.baseToken = function (n) {
      var this$1 = this;

if (!this.baseTokens) { return null }
    while (this.baseTokens[this.baseTokenPos] <= n)
      { this$1.baseTokenPos += 2; }
    var type = this.baseTokens[this.baseTokenPos + 1];
    return {type: type && type.replace(/( |^)overlay .*/, ""),
            size: this.baseTokens[this.baseTokenPos] - n}
  };

Context.prototype.nextLine = function () {
    this.line++;
    if (this.maxLookAhead > 0) { this.maxLookAhead--; }
  };

Context.fromSaved = function (doc, saved, line) {
    if (saved instanceof SavedContext)
      { return new Context(doc, copyState(doc.mode, saved.state), line, saved.lookAhead) }
    else
      { return new Context(doc, copyState(doc.mode, saved), line) }
  };

Context.prototype.save = function (copy) {
    var state = copy !== false ? copyState(this.doc.mode, this.state) : this.state;
    return this.maxLookAhead > 0 ? new SavedContext(state, this.maxLookAhead) : state
  };

// Compute a style array (an array starting with a mode generation
  // -- for invalidation -- followed by pairs of end positions and
  // style strings), which is used to highlight the tokens on the
  // line.
  function highlightLine(cm, line, context, forceToEnd) {
    // A styles array always starts with a number identifying the
    // mode/overlays that it is based on (for easy invalidation).
    var st = [cm.state.modeGen], lineClasses = {};
    // Compute the base array of styles
    runMode(cm, line.text, cm.doc.mode, context, function (end, style) { return st.push(end, style); },
            lineClasses, forceToEnd);
    var state = context.state;

// Run overlays, adjust style array.
    var loop = function ( o ) {
      context.baseTokens = st;
      var overlay = cm.state.overlays[o], i = 1, at = 0;
      context.state = true;
      runMode(cm, line.text, overlay.mode, context, function (end, style) {
        var start = i;
        // Ensure there's a token end at the current position, and that i points at it
        while (at < end) {
          var i_end = st[i];
          if (i_end > end)
            { st.splice(i, 1, end, st[i+1], i_end); }
          i += 2;
          at = Math.min(end, i_end);
        }
        if (!style) { return }
        if (overlay.opaque) {
          st.splice(start, i - start, end, "overlay " + style);
          i = start + 2;
        } else {
          for (; start < i; start += 2) {
            var cur = st[start+1];
            st[start+1] = (cur ? cur + " " : "") + "overlay " + style;
          }
        }
      }, lineClasses);
      context.state = state;
      context.baseTokens = null;
      context.baseTokenPos = 1;
    };

for (var o = 0; o < cm.state.overlays.length; ++o) loop( o );

return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}
  }

function getContextBefore(cm, n, precise) {
    var doc = cm.doc, display = cm.display;
    if (!doc.mode.startState) { return new Context(doc, true, n) }
    var start = findStartLine(cm, n, precise);
    var saved = start > doc.first && getLine(doc, start - 1).stateAfter;
    var context = saved ? Context.fromSaved(doc, saved, start) : new Context(doc, startState(doc.mode), start);

doc.iter(start, n, function (line) {
      processLine(cm, line.text, context);
      var pos = context.line;
      line.stateAfter = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo ? context.save() : null;
      context.nextLine();
    });
    if (precise) { doc.modeFrontier = context.line; }
    return context
  }

// Lightweight form of highlight -- proceed over this line and
  // update state, but don't save a style array. Used for lines that
  // aren't currently visible.
  function processLine(cm, text, context, startAt) {
    var mode = cm.doc.mode;
    var stream = new StringStream(text, cm.options.tabSize, context);
    stream.start = stream.pos = startAt || 0;
    if (text == "") { callBlankLine(mode, context.state); }
    while (!stream.eol()) {
      readToken(mode, stream, context.state);
      stream.start = stream.pos;
    }
  }

function callBlankLine(mode, state) {
    if (mode.blankLine) { return mode.blankLine(state) }
    if (!mode.innerMode) { return }
    var inner = innerMode(mode, state);
    if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) }
  }

var Token = function(stream, type, state) {
    this.start = stream.start; this.end = stream.pos;
    this.string = stream.current();
    this.type = type || null;
    this.state = state;
  };

// Utility for getTokenAt and getLineTokens
  function takeToken(cm, pos, precise, asArray) {
    var doc = cm.doc, mode = doc.mode, style;
    pos = clipPos(doc, pos);
    var line = getLine(doc, pos.line), context = getContextBefore(cm, pos.line, precise);
    var stream = new StringStream(line.text, cm.options.tabSize, context), tokens;
    if (asArray) { tokens = []; }
    while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
      stream.start = stream.pos;
      style = readToken(mode, stream, context.state);
      if (asArray) { tokens.push(new Token(stream, style, copyState(doc.mode, context.state))); }
    }
    return asArray ? tokens : new Token(stream, style, context.state)
  }

// Run the given mode's parser over a line, calling f for each token.
  function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) {
    var flattenSpans = mode.flattenSpans;
    if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans; }
    var curStart = 0, curStyle = null;
    var stream = new StringStream(text, cm.options.tabSize, context), style;
    var inner = cm.options.addModeClass && [null];
    if (text == "") { extractLineClasses(callBlankLine(mode, context.state), lineClasses); }
    while (!stream.eol()) {
      if (stream.pos > cm.options.maxHighlightLength) {
        flattenSpans = false;
        if (forceToEnd) { processLine(cm, text, context, stream.pos); }
        stream.pos = text.length;
        style = null;
      } else {
        style = extractLineClasses(readToken(mode, stream, context.state, inner), lineClasses);
      }
      if (inner) {
        var mName = inner[0].name;
        if (mName) { style = "m-" + (style ? mName + " " + style : mName); }
      }
      if (!flattenSpans || curStyle != style) {
        while (curStart < stream.start) {
          curStart = Math.min(stream.start, curStart + 5000);
          f(curStart, curStyle);
        }
        curStyle = style;
      }
      stream.start = stream.pos;
    }
    while (curStart < stream.pos) {
      // Webkit seems to refuse to render text nodes longer than 57444
      // characters, and returns inaccurate measurements in nodes
      // starting around 5000 chars.
      var pos = Math.min(stream.pos, curStart + 5000);
      f(pos, curStyle);
      curStart = pos;
    }
  }

// Finds the line to start with when starting a parse. Tries to
  // find a line with a stateAfter, so that it can start with a
  // valid state. If that fails, it returns the line with the
  // smallest indentation, which tends to need the least context to
  // parse correctly.
  function findStartLine(cm, n, precise) {
    var minindent, minline, doc = cm.doc;
    var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100);
    for (var search = n; search > lim; --search) {
      if (search <= doc.first) { return doc.first }
      var line = getLine(doc, search - 1), after = line.stateAfter;
      if (after && (!precise || search + (after instanceof SavedContext ? after.lookAhead : 0) <= doc.modeFrontier))
        { return search }
      var indented = countColumn(line.text, null, cm.options.tabSize);
      if (minline == null || minindent > indented) {
        minline = search - 1;
        minindent = indented;
      }
    }
    return minline
  }

// LINE DATA STRUCTURE

// Line objects. These hold state related to a line, including
  // highlighting info (the styles array).
  var Line = function(text, markedSpans, estimateHeight) {
    this.text = text;
    attachMarkedSpans(this, markedSpans);
    this.height = estimateHeight ? estimateHeight(this) : 1;
  };

Line.prototype.lineNo = function () { return lineNo(this) };
  eventMixin(Line);

// Change the content (text, markers) of a line. Automatically
  // invalidates cached information and tries to re-estimate the
  // line's height.
  function updateLine(line, text, markedSpans, estimateHeight) {
    line.text = text;
    if (line.stateAfter) { line.stateAfter = null; }
    if (line.styles) { line.styles = null; }
    if (line.order != null) { line.order = null; }
    detachMarkedSpans(line);
    attachMarkedSpans(line, markedSpans);
    var estHeight = estimateHeight ? estimateHeight(line) : 1;
    if (estHeight != line.height) { updateLineHeight(line, estHeight); }
  }

// Detach a line from the document tree and its markers.
  function cleanUpLine(line) {
    line.parent = null;
    detachMarkedSpans(line);
  }

// Convert a style as returned by a mode (either null, or a string
  // containing one or more styles) to a CSS style. This is cached,
  // and also looks for line-wide styles.
  var styleToClassCache = {}, styleToClassCacheWithMode = {};
  function interpretTokenStyle(style, options) {
    if (!style || /^\s*$/.test(style)) { return null }
    var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache;
    return cache[style] ||
      (cache[style] = style.replace(/\S+/g, "cm-$&"))
  }

// Render the DOM representation of the text of a line. Also builds
  // up a 'line map', which points at the DOM nodes that represent
  // specific stretches of text, and is used by the measuring code.
  // The returned object contains the DOM node, this map, and
  // information about line-wide styles that were set by the mode.
  function buildLineContent(cm, lineView) {
    // The padding-right forces the element to have a 'border', which
    // is needed on Webkit to be able to get line-level bounding
    // rectangles for it (in measureChar).
    var content = eltP("span", null, null, webkit ? "padding-right: .1px" : null);
    var builder = {pre: eltP("pre", [content], "CodeMirror-line"), content: content,
                   col: 0, pos: 0, cm: cm,
                   trailingSpace: false,
                   splitSpaces: cm.getOption("lineWrapping")};
    lineView.measure = {};

// Iterate over the logical lines that make up this visual line.
    for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
      var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0);
      builder.pos = 0;
      builder.addToken = buildToken;
      // Optionally wire in some hacks into the token-rendering
      // algorithm, to deal with browser quirks.
      if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line, cm.doc.direction)))
        { builder.addToken = buildTokenBadBidi(builder.addToken, order); }
      builder.map = [];
      var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line);
      insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate));
      if (line.styleClasses) {
        if (line.styleClasses.bgClass)
          { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || ""); }
        if (line.styleClasses.textClass)
          { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || ""); }
      }

// Ensure at least a single node is present, for measuring.
      if (builder.map.length == 0)
        { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))); }

// Store the map and a cache object for the current logical line
      if (i == 0) {
        lineView.measure.map = builder.map;
        lineView.measure.cache = {};
      } else {
  (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)
        ;(lineView.measure.caches || (lineView.measure.caches = [])).push({});
      }
    }

// See issue #2901
    if (webkit) {
      var last = builder.content.lastChild;
      if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab")))
        { builder.content.className = "cm-tab-wrap-hack"; }
    }

signal(cm, "renderLine", cm, lineView.line, builder.pre);
    if (builder.pre.className)
      { builder.textClass = joinClasses(builder.pre.className, builder.textClass || ""); }

return builder
  }

function defaultSpecialCharPlaceholder(ch) {
    var token = elt("span", "\u2022", "cm-invalidchar");
    token.title = "\\u" + ch.charCodeAt(0).toString(16);
    token.setAttribute("aria-label", token.title);
    return token
  }

// Build up the DOM representation for a single token, and add it to
  // the line map. Takes care to render special characters separately.
  function buildToken(builder, text, style, startStyle, endStyle, css, attributes) {
    if (!text) { return }
    var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text;
    var special = builder.cm.state.specialChars, mustWrap = false;
    var content;
    if (!special.test(text)) {
      builder.col += text.length;
      content = document.createTextNode(displayText);
      builder.map.push(builder.pos, builder.pos + text.length, content);
      if (ie && ie_version < 9) { mustWrap = true; }
      builder.pos += text.length;
    } else {
      content = document.createDocumentFragment();
      var pos = 0;
      while (true) {
        special.lastIndex = pos;
        var m = special.exec(text);
        var skipped = m ? m.index - pos : text.length - pos;
        if (skipped) {
          var txt = document.createTextNode(displayText.slice(pos, pos + skipped));
          if (ie && ie_version < 9) { content.appendChild(elt("span", [txt])); }
          else { content.appendChild(txt); }
          builder.map.push(builder.pos, builder.pos + skipped, txt);
          builder.col += skipped;
          builder.pos += skipped;
        }
        if (!m) { break }
        pos += skipped + 1;
        var txt$1 = (void 0);
        if (m[0] == "\t") {
          var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize;
          txt$1 = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"));
          txt$1.setAttribute("role", "presentation");
          txt$1.setAttribute("cm-text", "\t");
          builder.col += tabWidth;
        } else if (m[0] == "\r" || m[0] == "\n") {
          txt$1 = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar"));
          txt$1.setAttribute("cm-text", m[0]);
          builder.col += 1;
        } else {
          txt$1 = builder.cm.options.specialCharPlaceholder(m[0]);
          txt$1.setAttribute("cm-text", m[0]);
          if (ie && ie_version < 9) { content.appendChild(elt("span", [txt$1])); }
          else { content.appendChild(txt$1); }
          builder.col += 1;
        }
        builder.map.push(builder.pos, builder.pos + 1, txt$1);
        builder.pos++;
      }
    }
    builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32;
    if (style || startStyle || endStyle || mustWrap || css) {
      var fullStyle = style || "";
      if (startStyle) { fullStyle += startStyle; }
      if (endStyle) { fullStyle += endStyle; }
      var token = elt("span", [content], fullStyle, css);
      if (attributes) {
        for (var attr in attributes) { if (attributes.hasOwnProperty(attr) && attr != "style" && attr != "class")
          { token.setAttribute(attr, attributes[attr]); } }
      }
      return builder.content.appendChild(token)
    }
    builder.content.appendChild(content);
  }

// Change some spaces to NBSP to prevent the browser from collapsing
  // trailing spaces at the end of a line when rendering text (issue #1362).
  function splitSpaces(text, trailingBefore) {
    if (text.length > 1 && !/  /.test(text)) { return text }
    var spaceBefore = trailingBefore, result = "";
    for (var i = 0; i < text.length; i++) {
      var ch = text.charAt(i);
      if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))
        { ch = "\u00a0"; }
      result += ch;
      spaceBefore = ch == " ";
    }
    return result
  }

// Work around nonsense dimensions being reported for stretches of
  // right-to-left text.
  function buildTokenBadBidi(inner, order) {
    return function (builder, text, style, startStyle, endStyle, css, attributes) {
      style = style ? style + " cm-force-border" : "cm-force-border";
      var start = builder.pos, end = start + text.length;
      for (;;) {
        // Find the part that overlaps with the start of this text
        var part = (void 0);
        for (var i = 0; i < order.length; i++) {
          part = order[i];
          if (part.to > start && part.from <= start) { break }
        }
        if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, css, attributes) }
        inner(builder, text.slice(0, part.to - start), style, startStyle, null, css, attributes);
        startStyle = null;
        text = text.slice(part.to - start);
        start = part.to;
      }
    }
  }

// Outputs a number of spans to make up a line, taking highlighting
  // and marked text into account.
  function insertLineContent(line, builder, styles) {
    var spans = line.markedSpans, allText = line.text, at = 0;
    if (!spans) {
      for (var i$1 = 1; i$1 < styles.length; i$1+=2)
        { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)); }
      return
    }

if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2)
          { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]); } }
        if (collapsed && (collapsed.from || 0) == pos) {
          buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
                             collapsed.marker, collapsed.from == null);
          if (collapsed.to == null) { return }
          if (collapsed.to == pos) { collapsed = false; }
        }
      }
      if (pos >= len) { break }

// These objects are used to represent the visible (currently drawn)
  // part of the document. A LineView may correspond to multiple
  // logical lines, if those are connected by collapsed ranges.
  function LineView(doc, line, lineN) {
    // The starting line
    this.line = line;
    // Continuing lines, if any
    this.rest = visualLineContinued(line);
    // Number of logical lines in this visual line
    this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1;
    this.node = this.text = null;
    this.hidden = lineIsHidden(doc, line);
  }

// Create a range of LineView objects for the given lines.
  function buildViewArray(cm, from, to) {
    var array = [], nextPos;
    for (var pos = from; pos < to; pos = nextPos) {
      var view = new LineView(cm.doc, getLine(cm.doc, pos), pos);
      nextPos = pos + view.size;
      array.push(view);
    }
    return array
  }

var operationGroup = null;

function pushOperation(op) {
    if (operationGroup) {
      operationGroup.ops.push(op);
    } else {
      op.ownsGroup = operationGroup = {
        ops: [op],
        delayedCallbacks: []
      };
    }
  }

function finishOperation(op, endCb) {
    var group = op.ownsGroup;
    if (!group) { return }

try { fireCallbacksForOps(group); }
    finally {
      operationGroup = null;
      endCb(group);
    }
  }

var orphanDelayedCallbacks = null;

// Often, we want to signal events at a point where we are in the
  // middle of some work, but don't want the handler to start calling
  // other methods on the editor, which might be in an inconsistent
  // state or simply not expect any other events to happen.
  // signalLater looks whether there are any handlers, and schedules
  // them to be executed when the last operation ends, or, if no
  // operation is active, when a timeout fires.
  function signalLater(emitter, type /*, values...*/) {
    var arr = getHandlers(emitter, type);
    if (!arr.length) { return }
    var args = Array.prototype.slice.call(arguments, 2), list;
    if (operationGroup) {
      list = operationGroup.delayedCallbacks;
    } else if (orphanDelayedCallbacks) {
      list = orphanDelayedCallbacks;
    } else {
      list = orphanDelayedCallbacks = [];
      setTimeout(fireOrphanDelayed, 0);
    }
    var loop = function ( i ) {
      list.push(function () { return arr[i].apply(null, args); });
    };

for (var i = 0; i < arr.length; ++i)
      loop( i );
  }

function fireOrphanDelayed() {
    var delayed = orphanDelayedCallbacks;
    orphanDelayedCallbacks = null;
    for (var i = 0; i < delayed.length; ++i) { delayed[i](); }
  }

// When an aspect of a line changes, a string is added to
  // lineView.changes. This updates the relevant part of the line's
  // DOM structure.
  function updateLineForChanges(cm, lineView, lineN, dims) {
    for (var j = 0; j < lineView.changes.length; j++) {
      var type = lineView.changes[j];
      if (type == "text") { updateLineText(cm, lineView); }
      else if (type == "gutter") { updateLineGutter(cm, lineView, lineN, dims); }
      else if (type == "class") { updateLineClasses(cm, lineView); }
      else if (type == "widget") { updateLineWidgets(cm, lineView, dims); }
    }
    lineView.changes = null;
  }

// Lines with gutter elements, widgets or a background class need to
  // be wrapped, and have the extra elements added to the wrapper div
  function ensureLineWrapped(lineView) {
    if (lineView.node == lineView.text) {
      lineView.node = elt("div", null, null, "position: relative");
      if (lineView.text.parentNode)
        { lineView.text.parentNode.replaceChild(lineView.node, lineView.text); }
      lineView.node.appendChild(lineView.text);
      if (ie && ie_version < 8) { lineView.node.style.zIndex = 2; }
    }
    return lineView.node
  }

// Wrapper around buildLineContent which will reuse the structure
  // in display.externalMeasured when possible.
  function getLineContent(cm, lineView) {
    var ext = cm.display.externalMeasured;
    if (ext && ext.line == lineView.line) {
      cm.display.externalMeasured = null;
      lineView.measure = ext.measure;
      return ext.built
    }
    return buildLineContent(cm, lineView)
  }

// Redraw the line's text. Interacts with the background and text
  // classes because the mode may output tokens that influence these
  // classes.
  function updateLineText(cm, lineView) {
    var cls = lineView.text.className;
    var built = getLineContent(cm, lineView);
    if (lineView.text == lineView.node) { lineView.node = built.pre; }
    lineView.text.parentNode.replaceChild(built.pre, lineView.text);
    lineView.text = built.pre;
    if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
      lineView.bgClass = built.bgClass;
      lineView.textClass = built.textClass;
      updateLineClasses(cm, lineView);
    } else if (cls) {
      lineView.text.className = cls;
    }
  }

// Build a line's DOM representation from scratch
  function buildLineElement(cm, lineView, lineN, dims) {
    var built = getLineContent(cm, lineView);
    lineView.text = lineView.node = built.pre;
    if (built.bgClass) { lineView.bgClass = built.bgClass; }
    if (built.textClass) { lineView.textClass = built.textClass; }

updateLineClasses(cm, lineView);
    updateLineGutter(cm, lineView, lineN, dims);
    insertLineWidgets(cm, lineView, dims);
    return lineView.node
  }

// A lineView may contain multiple logical lines (when merged by
  // collapsed spans). The widgets for all of them need to be drawn.
  function insertLineWidgets(cm, lineView, dims) {
    insertLineWidgetsFor(cm, lineView.line, lineView, dims, true);
    if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
      { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false); } }
  }

// Return true when the given mouse event happened in a widget
  function eventInWidget(display, e) {
    for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
      if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") ||
          (n.parentNode == display.sizer && n != display.mover))
        { return true }
    }
  }

// POSITION MEASUREMENT

function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }
  function displayWidth(cm) {
    return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth
  }
  function displayHeight(cm) {
    return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight
  }

// Ensure the lineView.wrapping.heights array is populated. This is
  // an array of bottom offsets for the lines that make up a drawn
  // line. When lineWrapping is on, there might be more than one
  // height.
  function ensureLineHeights(cm, lineView, rect) {
    var wrapping = cm.options.lineWrapping;
    var curWidth = wrapping && displayWidth(cm);
    if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {
      var heights = lineView.measure.heights = [];
      if (wrapping) {
        lineView.measure.width = curWidth;
        var rects = lineView.text.firstChild.getClientRects();
        for (var i = 0; i < rects.length - 1; i++) {
          var cur = rects[i], next = rects[i + 1];
          if (Math.abs(cur.bottom - next.bottom) > 2)
            { heights.push((cur.bottom + next.top) / 2 - rect.top); }
        }
      }
      heights.push(rect.bottom - rect.top);
    }
  }

// Find a line map (mapping character offsets to text nodes) and a
  // measurement cache for the given line number. (A line view might
  // contain multiple lines when collapsed ranges are present.)
  function mapFromLineView(lineView, line, lineN) {
    if (lineView.line == line)
      { return {map: lineView.measure.map, cache: lineView.measure.cache} }
    for (var i = 0; i < lineView.rest.length; i++)
      { if (lineView.rest[i] == line)
        { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } }
    for (var i$1 = 0; i$1 < lineView.rest.length; i$1++)
      { if (lineNo(lineView.rest[i$1]) > lineN)
        { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } }
  }

// Render a line into the hidden node display.externalMeasured. Used
  // when measurement is needed for a line that's not in the viewport.
  function updateExternalMeasurement(cm, line) {
    line = visualLine(line);
    var lineN = lineNo(line);
    var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN);
    view.lineN = lineN;
    var built = view.built = buildLineContent(cm, view);
    view.text = built.pre;
    removeChildrenAndAdd(cm.display.lineMeasure, built.pre);
    return view
  }

// Get a {top, bottom, left, right} box (in line-local coordinates)
  // for a given character.
  function measureChar(cm, line, ch, bias) {
    return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias)
  }

// Find a line view that corresponds to the given line number.
  function findViewForLine(cm, lineN) {
    if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
      { return cm.display.view[findViewIndex(cm, lineN)] }
    var ext = cm.display.externalMeasured;
    if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
      { return ext }
  }

// Measurement can be split in two steps, the set-up work that
  // applies to the whole line, and the measurement of the actual
  // character. Functions like coordsChar, that need to do a lot of
  // measurements in a row, can thus ensure that the set-up work is
  // only done once.
  function prepareMeasureForLine(cm, line) {
    var lineN = lineNo(line);
    var view = findViewForLine(cm, lineN);
    if (view && !view.text) {
      view = null;
    } else if (view && view.changes) {
      updateLineForChanges(cm, view, lineN, getDimensions(cm));
      cm.curOp.forceUpdate = true;
    }
    if (!view)
      { view = updateExternalMeasurement(cm, line); }

var info = mapFromLineView(view, line, lineN);
    return {
      line: line, view: view, rect: null,
      map: info.map, cache: info.cache, before: info.before,
      hasHeights: false
    }
  }

// Given a prepared measurement object, measures the position of an
  // actual character (or fetches it from the cache).
  function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
    if (prepared.before) { ch = -1; }
    var key = ch + (bias || ""), found;
    if (prepared.cache.hasOwnProperty(key)) {
      found = prepared.cache[key];
    } else {
      if (!prepared.rect)
        { prepared.rect = prepared.view.text.getBoundingClientRect(); }
      if (!prepared.hasHeights) {
        ensureLineHeights(cm, prepared.view, prepared.rect);
        prepared.hasHeights = true;
      }
      found = measureCharInner(cm, prepared, ch, bias);
      if (!found.bogus) { prepared.cache[key] = found; }
    }
    return {left: found.left, right: found.right,
            top: varHeight ? found.rtop : found.top,
            bottom: varHeight ? found.rbottom : found.bottom}
  }

var nullRect = {left: 0, right: 0, top: 0, bottom: 0};

function measureCharInner(cm, prepared, ch, bias) {
    var place = nodeAndOffsetInLineMap(prepared.map, ch, bias);
    var node = place.node, start = place.start, end = place.end, collapse = place.collapse;

var rect;
    if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.
      for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned
        while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start; }
        while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end; }
        if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)
          { rect = node.parentNode.getBoundingClientRect(); }
        else
          { rect = getUsefulRect(range(node, start, end).getClientRects(), bias); }
        if (rect.left || rect.right || start == 0) { break }
        end = start;
        start = start - 1;
        collapse = "right";
      }
      if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect); }
    } else { // If it is a widget, simply get the box for the whole widget.
      if (start > 0) { collapse = bias = "right"; }
      var rects;
      if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)
        { rect = rects[bias == "right" ? rects.length - 1 : 0]; }
      else
        { rect = node.getBoundingClientRect(); }
    }
    if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {
      var rSpan = node.parentNode.getClientRects()[0];
      if (rSpan)
        { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom}; }
      else
        { rect = nullRect; }
    }

return result
  }

// Work around problem with bounding client rects on ranges being
  // returned incorrectly when zoomed on IE10 and below.
  function maybeUpdateRectForZooming(measure, rect) {
    if (!window.screen || screen.logicalXDPI == null ||
        screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))
      { return rect }
    var scaleX = screen.logicalXDPI / screen.deviceXDPI;
    var scaleY = screen.logicalYDPI / screen.deviceYDPI;
    return {left: rect.left * scaleX, right: rect.right * scaleX,
            top: rect.top * scaleY, bottom: rect.bottom * scaleY}
  }

function clearLineMeasurementCache(cm) {
    cm.display.externalMeasure = null;
    removeChildren(cm.display.lineMeasure);
    for (var i = 0; i < cm.display.view.length; i++)
      { clearLineMeasurementCacheFor(cm.display.view[i]); }
  }

function clearCaches(cm) {
    clearLineMeasurementCache(cm);
    cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null;
    if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true; }
    cm.display.lineNumChars = null;
  }

function pageScrollX() {
    // Work around https://bugs.chromium.org/p/chromium/issues/detail?id=489206
    // which causes page_Offset and bounding client rects to use
    // different reference viewports and invalidate our calculations.
    if (chrome && android) { return -(document.body.getBoundingClientRect().left - parseInt(getComputedStyle(document.body).marginLeft)) }
    return window.pageXOffset || (document.documentElement || document.body).scrollLeft
  }
  function pageScrollY() {
    if (chrome && android) { return -(document.body.getBoundingClientRect().top - parseInt(getComputedStyle(document.body).marginTop)) }
    return window.pageYOffset || (document.documentElement || document.body).scrollTop
  }

// Converts a {top, bottom, left, right} box from line-local
  // coordinates into another coordinate system. Context may be one of
  // "line", "div" (display.lineDiv), "local"./null (editor), "window",
  // or "page".
  function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {
    if (!includeWidgets) {
      var height = widgetTopHeight(lineObj);
      rect.top += height; rect.bottom += height;
    }
    if (context == "line") { return rect }
    if (!context) { context = "local"; }
    var yOff = heightAtLine(lineObj);
    if (context == "local") { yOff += paddingTop(cm.display); }
    else { yOff -= cm.display.viewOffset; }
    if (context == "page" || context == "window") {
      var lOff = cm.display.lineSpace.getBoundingClientRect();
      yOff += lOff.top + (context == "window" ? 0 : pageScrollY());
      var xOff = lOff.left + (context == "window" ? 0 : pageScrollX());
      rect.left += xOff; rect.right += xOff;
    }
    rect.top += yOff; rect.bottom += yOff;
    return rect
  }

// Coverts a box from "div" coords to another coordinate system.
  // Context may be "window", "page", "div", or "local"./null.
  function fromCoordSystem(cm, coords, context) {
    if (context == "div") { return coords }
    var left = coords.left, top = coords.top;
    // First move into "page" coordinate system
    if (context == "page") {
      left -= pageScrollX();
      top -= pageScrollY();
    } else if (context == "local" || !context) {
      var localBox = cm.display.sizer.getBoundingClientRect();
      left += localBox.left;
      top += localBox.top;
    }

var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect();
    return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top}
  }

function charCoords(cm, pos, context, lineObj, bias) {
    if (!lineObj) { lineObj = getLine(cm.doc, pos.line); }
    return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context)
  }

// Returns a box for a given cursor position, which may have an
  // 'other' property containing the position of the secondary cursor
  // on a bidi boundary.
  // A cursor Pos(line, char, "before") is on the same visual line as `char - 1`
  // and after `char - 1` in writing order of `char - 1`
  // A cursor Pos(line, char, "after") is on the same visual line as `char`
  // and before `char` in writing order of `char`
  // Examples (upper-case letters are RTL, lower-case are LTR):
  //     Pos(0, 1, ...)
  //     before   after
  // ab     a|b     a|b
  // aB     a|B     aB|
  // Ab     |Ab     A|b
  // AB     B|A     B|A
  // Every position after the last character on a line is considered to stick
  // to the last character on the line.
  function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {
    lineObj = lineObj || getLine(cm.doc, pos.line);
    if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); }
    function get(ch, right) {
      var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight);
      if (right) { m.left = m.right; } else { m.right = m.left; }
      return intoCoordSystem(cm, lineObj, m, context)
    }
    var order = getOrder(lineObj, cm.doc.direction), ch = pos.ch, sticky = pos.sticky;
    if (ch >= lineObj.text.length) {
      ch = lineObj.text.length;
      sticky = "before";
    } else if (ch <= 0) {
      ch = 0;
      sticky = "after";
    }
    if (!order) { return get(sticky == "before" ? ch - 1 : ch, sticky == "before") }

function getBidi(ch, partPos, invert) {
      var part = order[partPos], right = part.level == 1;
      return get(invert ? ch - 1 : ch, right != invert)
    }
    var partPos = getBidiPartAt(order, ch, sticky);
    var other = bidiOther;
    var val = getBidi(ch, partPos, sticky == "before");
    if (other != null) { val.other = getBidi(ch, other, sticky != "before"); }
    return val
  }

// Used to cheaply estimate the coordinates for a position. Used for
  // intermediate scroll updates.
  function estimateCoords(cm, pos) {
    var left = 0;
    pos = clipPos(cm.doc, pos);
    if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch; }
    var lineObj = getLine(cm.doc, pos.line);
    var top = heightAtLine(lineObj) + paddingTop(cm.display);
    return {left: left, right: left, top: top, bottom: top + lineObj.height}
  }

// Positions returned by coordsChar contain some extra information.
  // xRel is the relative x position of the input coordinates compared
  // to the found position (so xRel > 0 means the coordinates are to
  // the right of the character position, for example). When outside
  // is true, that means the coordinates lie outside the line's
  // vertical range.
  function PosWithInfo(line, ch, sticky, outside, xRel) {
    var pos = Pos(line, ch, sticky);
    pos.xRel = xRel;
    if (outside) { pos.outside = true; }
    return pos
  }

// Compute the character position closest to the given coordinates.
  // Input must be lineSpace-local ("div" coordinate system).
  function coordsChar(cm, x, y) {
    var doc = cm.doc;
    y += cm.display.viewOffset;
    if (y < 0) { return PosWithInfo(doc.first, 0, null, true, -1) }
    var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1;
    if (lineN > last)
      { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, null, true, 1) }
    if (x < 0) { x = 0; }

function wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) {
    if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); }
    var targetTop = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, target), "line").top;
    return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop)
  }

// Returns true if the given side of a box is after the given
  // coordinates, in top-to-bottom, left-to-right order.
  function boxIsAfter(box, x, y, left) {
    return box.bottom <= y ? false : box.top > y ? true : (left ? box.left : box.right) > x
  }

function coordsCharInner(cm, lineObj, lineNo$$1, x, y) {
    // Move y into line-local coordinate space
    y -= heightAtLine(lineObj);
    var preparedMeasure = prepareMeasureForLine(cm, lineObj);
    // When directly calling `measureCharPrepared`, we have to adjust
    // for the widgets at this line.
    var widgetHeight$$1 = widgetTopHeight(lineObj);
    var begin = 0, end = lineObj.text.length, ltr = true;

var order = getOrder(lineObj, cm.doc.direction);
    // If the line isn't plain left-to-right text, first figure out
    // which bidi section the coordinates fall into.
    if (order) {
      var part = (cm.options.lineWrapping ? coordsBidiPartWrapped : coordsBidiPart)
                   (cm, lineObj, lineNo$$1, preparedMeasure, order, x, y);
      ltr = part.level != 1;
      // The awkward -1 offsets are needed because findFirst (called
      // on these below) will treat its first bound as inclusive,
      // second as exclusive, but we want to actually address the
      // characters in the part's range
      begin = ltr ? part.from : part.to - 1;
      end = ltr ? part.to : part.from - 1;
    }

// A binary search to find the first character whose bounding box
    // starts after the coordinates. If we run across any whose box wrap
    // the coordinates, store that.
    var chAround = null, boxAround = null;
    var ch = findFirst(function (ch) {
      var box = measureCharPrepared(cm, preparedMeasure, ch);
      box.top += widgetHeight$$1; box.bottom += widgetHeight$$1;
      if (!boxIsAfter(box, x, y, false)) { return false }
      if (box.top <= y && box.left <= x) {
        chAround = ch;
        boxAround = box;
      }
      return true
    }, begin, end);

var baseX, sticky, outside = false;
    // If a box around the coordinates was found, use that
    if (boxAround) {
      // Distinguish coordinates nearer to the left or right side of the box
      var atLeft = x - boxAround.left < boxAround.right - x, atStart = atLeft == ltr;
      ch = chAround + (atStart ? 0 : 1);
      sticky = atStart ? "after" : "before";
      baseX = atLeft ? boxAround.left : boxAround.right;
    } else {
      // (Adjust for extended bound, if necessary.)
      if (!ltr && (ch == end || ch == begin)) { ch++; }
      // To determine which side to associate with, get the box to the
      // left of the character and compare it's vertical position to the
      // coordinates
      sticky = ch == 0 ? "after" : ch == lineObj.text.length ? "before" :
        (measureCharPrepared(cm, preparedMeasure, ch - (ltr ? 1 : 0)).bottom + widgetHeight$$1 <= y) == ltr ?
        "after" : "before";
      // Now get accurate coordinates for this place, in order to get a
      // base X position
      var coords = cursorCoords(cm, Pos(lineNo$$1, ch, sticky), "line", lineObj, preparedMeasure);
      baseX = coords.left;
      outside = y < coords.top || y >= coords.bottom;
    }

ch = skipExtendingChars(lineObj.text, ch, 1);
    return PosWithInfo(lineNo$$1, ch, sticky, outside, x - baseX)
  }

var measureText;
  // Compute the default text height.
  function textHeight(display) {
    if (display.cachedTextHeight != null) { return display.cachedTextHeight }
    if (measureText == null) {
      measureText = elt("pre");
      // Measure a bunch of lines, for browsers that compute
      // fractional heights.
      for (var i = 0; i < 49; ++i) {
        measureText.appendChild(document.createTextNode("x"));
        measureText.appendChild(elt("br"));
      }
      measureText.appendChild(document.createTextNode("x"));
    }
    removeChildrenAndAdd(display.measure, measureText);
    var height = measureText.offsetHeight / 50;
    if (height > 3) { display.cachedTextHeight = height; }
    removeChildren(display.measure);
    return height || 1
  }

// Compute the default character width.
  function charWidth(display) {
    if (display.cachedCharWidth != null) { return display.cachedCharWidth }
    var anchor = elt("span", "xxxxxxxxxx");
    var pre = elt("pre", [anchor]);
    removeChildrenAndAdd(display.measure, pre);
    var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10;
    if (width > 2) { display.cachedCharWidth = width; }
    return width || 10
  }

// Do a bulk-read of the DOM positions and sizes needed to draw the
  // view, so that we don't interleave reading and writing to the DOM.
  function getDimensions(cm) {
    var d = cm.display, left = {}, width = {};
    var gutterLeft = d.gutters.clientLeft;
    for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {
      left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft;
      width[cm.options.gutters[i]] = n.clientWidth;
    }
    return {fixedPos: compensateForHScroll(d),
            gutterTotalWidth: d.gutters.offsetWidth,
            gutterLeft: left,
            gutterWidth: width,
            wrapperWidth: d.wrapper.clientWidth}
  }

// Computes display.scroller.scrollLeft + display.gutters.offsetWidth,
  // but using getBoundingClientRect to get a sub-pixel-accurate
  // result.
  function compensateForHScroll(display) {
    return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left
  }

// Returns a function that estimates the height of a line, to use as
  // first approximation until the line becomes visible (and is thus
  // properly measurable).
  function estimateHeight(cm) {
    var th = textHeight(cm.display), wrapping = cm.options.lineWrapping;
    var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);
    return function (line) {
      if (lineIsHidden(cm.doc, line)) { return 0 }

var widgetsHeight = 0;
      if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) {
        if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height; }
      } }

if (wrapping)
        { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th }
      else
        { return widgetsHeight + th }
    }
  }

// Given a mouse event, find the corresponding position. If liberal
  // is false, it checks whether a gutter or scrollbar was clicked,
  // and returns null if it was. forRect is used by rectangular
  // selections, and tries to estimate a character position even for
  // coordinates beyond the right of the text.
  function posFromMouse(cm, e, liberal, forRect) {
    var display = cm.display;
    if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") { return null }

var x, y, space = display.lineSpace.getBoundingClientRect();
    // Fails unpredictably on IE[67] when mouse is dragged around quickly.
    try { x = e.clientX - space.left; y = e.clientY - space.top; }
    catch (e) { return null }
    var coords = coordsChar(cm, x, y), line;
    if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {
      var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length;
      coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff));
    }
    return coords
  }

// Find the view element corresponding to a given line. Return null
  // when the line isn't visible.
  function findViewIndex(cm, n) {
    if (n >= cm.display.viewTo) { return null }
    n -= cm.display.viewFrom;
    if (n < 0) { return null }
    var view = cm.display.view;
    for (var i = 0; i < view.length; i++) {
      n -= view[i].size;
      if (n < 0) { return i }
    }
  }

function updateSelection(cm) {
    cm.display.input.showSelection(cm.display.input.prepareSelection());
  }

function prepareSelection(cm, primary) {
    if ( primary === void 0 ) primary = true;

var doc = cm.doc, result = {};
    var curFragment = result.cursors = document.createDocumentFragment();
    var selFragment = result.selection = document.createDocumentFragment();

for (var i = 0; i < doc.sel.ranges.length; i++) {
      if (!primary && i == doc.sel.primIndex) { continue }
      var range$$1 = doc.sel.ranges[i];
      if (range$$1.from().line >= cm.display.viewTo || range$$1.to().line < cm.display.viewFrom) { continue }
      var collapsed = range$$1.empty();
      if (collapsed || cm.options.showCursorWhenSelecting)
        { drawSelectionCursor(cm, range$$1.head, curFragment); }
      if (!collapsed)
        { drawSelectionRange(cm, range$$1, selFragment); }
    }
    return result
  }

// Draws a cursor for the given range
  function drawSelectionCursor(cm, head, output) {
    var pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine);

var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"));
    cursor.style.left = pos.left + "px";
    cursor.style.top = pos.top + "px";
    cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px";

if (pos.other) {
      // Secondary cursor, shown when on a 'jump' in bi-directional text
      var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"));
      otherCursor.style.display = "";
      otherCursor.style.left = pos.other.left + "px";
      otherCursor.style.top = pos.other.top + "px";
      otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px";
    }
  }

function cmpCoords(a, b) { return a.top - b.top || a.left - b.left }

// Draws the given range as a highlighted selection
  function drawSelectionRange(cm, range$$1, output) {
    var display = cm.display, doc = cm.doc;
    var fragment = document.createDocumentFragment();
    var padding = paddingH(cm.display), leftSide = padding.left;
    var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right;
    var docLTR = doc.direction == "ltr";

function add(left, top, width, bottom) {
      if (top < 0) { top = 0; }
      top = Math.round(top);
      bottom = Math.round(bottom);
      fragment.appendChild(elt("div", null, "CodeMirror-selected", ("position: absolute; left: " + left + "px;\n                             top: " + top + "px; width: " + (width == null ? rightSide - left : width) + "px;\n                             height: " + (bottom - top) + "px")));
    }

function drawForLine(line, fromArg, toArg) {
      var lineObj = getLine(doc, line);
      var lineLen = lineObj.text.length;
      var start, end;
      function coords(ch, bias) {
        return charCoords(cm, Pos(line, ch), "div", lineObj, bias)
      }

function wrapX(pos, dir, side) {
        var extent = wrappedLineExtentChar(cm, lineObj, null, pos);
        var prop = (dir == "ltr") == (side == "after") ? "left" : "right";
        var ch = side == "after" ? extent.begin : extent.end - (/\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1);
        return coords(ch, prop)[prop]
      }

var order = getOrder(lineObj, doc.direction);
      iterateBidiSections(order, fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir, i) {
        var ltr = dir == "ltr";
        var fromPos = coords(from, ltr ? "left" : "right");
        var toPos = coords(to - 1, ltr ? "right" : "left");

if (!start || cmpCoords(fromPos, start) < 0) { start = fromPos; }
        if (cmpCoords(toPos, start) < 0) { start = toPos; }
        if (!end || cmpCoords(fromPos, end) < 0) { end = fromPos; }
        if (cmpCoords(toPos, end) < 0) { end = toPos; }
      });
      return {start: start, end: end}
    }

output.appendChild(fragment);
  }

// Cursor-blinking
  function restartBlink(cm) {
    if (!cm.state.focused) { return }
    var display = cm.display;
    clearInterval(display.blinker);
    var on = true;
    display.cursorDiv.style.visibility = "";
    if (cm.options.cursorBlinkRate > 0)
      { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden"; },
        cm.options.cursorBlinkRate); }
    else if (cm.options.cursorBlinkRate < 0)
      { display.cursorDiv.style.visibility = "hidden"; }
  }

function ensureFocus(cm) {
    if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm); }
  }

function onFocus(cm, e) {
    if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false; }

if (cm.options.readOnly == "nocursor") { return }
    if (!cm.state.focused) {
      signal(cm, "focus", cm, e);
      cm.state.focused = true;
      addClass(cm.display.wrapper, "CodeMirror-focused");
      // This test prevents this from firing when a context
      // menu is closed (since the input reset would kill the
      // select-all detection hack)
      if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {
        cm.display.input.reset();
        if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20); } // Issue #1730
      }
      cm.display.input.receivedFocus();
    }
    restartBlink(cm);
  }
  function onBlur(cm, e) {
    if (cm.state.delayingBlurEvent) { return }

if (cm.state.focused) {
      signal(cm, "blur", cm, e);
      cm.state.focused = false;
      rmClass(cm.display.wrapper, "CodeMirror-focused");
    }
    clearInterval(cm.display.blinker);
    setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false; } }, 150);
  }

// Read the actual heights of the rendered lines, and update their
  // stored heights to match.
  function updateHeightsInViewport(cm) {
    var display = cm.display;
    var prevBottom = display.lineDiv.offsetTop;
    for (var i = 0; i < display.view.length; i++) {
      var cur = display.view[i], wrapping = cm.options.lineWrapping;
      var height = (void 0), width = 0;
      if (cur.hidden) { continue }
      if (ie && ie_version < 8) {
        var bot = cur.node.offsetTop + cur.node.offsetHeight;
        height = bot - prevBottom;
        prevBottom = bot;
      } else {
        var box = cur.node.getBoundingClientRect();
        height = box.bottom - box.top;
        // Check that lines don't extend past the right of the current
        // editor width
        if (!wrapping && cur.text.firstChild)
          { width = cur.text.firstChild.getBoundingClientRect().right - box.left - 1; }
      }
      var diff = cur.line.height - height;
      if (diff > .005 || diff < -.005) {
        updateLineHeight(cur.line, height);
        updateWidgetHeight(cur.line);
        if (cur.rest) { for (var j = 0; j < cur.rest.length; j++)
          { updateWidgetHeight(cur.rest[j]); } }
      }
      if (width > cm.display.sizerWidth) {
        var chWidth = Math.ceil(width / charWidth(cm.display));
        if (chWidth > cm.display.maxLineLength) {
          cm.display.maxLineLength = chWidth;
          cm.display.maxLine = cur.line;
          cm.display.maxLineChanged = true;
        }
      }
    }
  }

// Read and store the height of line widgets associated with the
  // given line.
  function updateWidgetHeight(line) {
    if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i) {
      var w = line.widgets[i], parent = w.node.parentNode;
      if (parent) { w.height = parent.offsetHeight; }
    } }
  }

// Compute the lines that are visible in a given viewport (defaults
  // the the current scroll position). viewport may contain top,
  // height, and ensure (see op.scrollToPos) properties.
  function visibleLines(display, doc, viewport) {
    var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop;
    top = Math.floor(top - paddingTop(display));
    var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight;

// Re-align line numbers and gutter marks to compensate for
  // horizontal scrolling.
  function alignHorizontally(cm) {
    var display = cm.display, view = display.view;
    if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return }
    var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft;
    var gutterW = display.gutters.offsetWidth, left = comp + "px";
    for (var i = 0; i < view.length; i++) { if (!view[i].hidden) {
      if (cm.options.fixedGutter) {
        if (view[i].gutter)
          { view[i].gutter.style.left = left; }
        if (view[i].gutterBackground)
          { view[i].gutterBackground.style.left = left; }
      }
      var align = view[i].alignable;
      if (align) { for (var j = 0; j < align.length; j++)
        { align[j].style.left = left; } }
    } }
    if (cm.options.fixedGutter)
      { display.gutters.style.left = (comp + gutterW) + "px"; }
  }

// Used to ensure that the line number gutter is still the right
  // size for the current document size. Returns true when an update
  // is needed.
  function maybeUpdateLineNumberWidth(cm) {
    if (!cm.options.lineNumbers) { return false }
    var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display;
    if (last.length != display.lineNumChars) {
      var test = display.measure.appendChild(elt("div", [elt("div", last)],
                                                 "CodeMirror-linenumber CodeMirror-gutter-elt"));
      var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW;
      display.lineGutter.style.width = "";
      display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1;
      display.lineNumWidth = display.lineNumInnerWidth + padding;
      display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;
      display.lineGutter.style.width = display.lineNumWidth + "px";
      updateGutterSpace(cm);
      return true
    }
    return false
  }

// SCROLLING THINGS INTO VIEW

// If an editor sits on the top or bottom of the window, partially
  // scrolled out of view, this ensures that the cursor is visible.
  function maybeScrollWindow(cm, rect) {
    if (signalDOMEvent(cm, "scrollCursorIntoView")) { return }

// Scroll a given position into view (immediately), verifying that
  // it actually became visible (as line heights are accurately
  // measured, the position of something may 'drift' during drawing).
  function scrollPosIntoView(cm, pos, end, margin) {
    if (margin == null) { margin = 0; }
    var rect;
    if (!cm.options.lineWrapping && pos == end) {
      // Set pos and end to the cursor positions around the character pos sticks to
      // If pos.sticky == "before", that is around pos.ch - 1, otherwise around pos.ch
      // If pos == Pos(_, 0, "before"), pos and end are unchanged
      pos = pos.ch ? Pos(pos.line, pos.sticky == "before" ? pos.ch - 1 : pos.ch, "after") : pos;
      end = pos.sticky == "before" ? Pos(pos.line, pos.ch + 1, "before") : pos;
    }
    for (var limit = 0; limit < 5; limit++) {
      var changed = false;
      var coords = cursorCoords(cm, pos);
      var endCoords = !end || end == pos ? coords : cursorCoords(cm, end);
      rect = {left: Math.min(coords.left, endCoords.left),
              top: Math.min(coords.top, endCoords.top) - margin,
              right: Math.max(coords.left, endCoords.left),
              bottom: Math.max(coords.bottom, endCoords.bottom) + margin};
      var scrollPos = calculateScrollPos(cm, rect);
      var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft;
      if (scrollPos.scrollTop != null) {
        updateScrollTop(cm, scrollPos.scrollTop);
        if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true; }
      }
      if (scrollPos.scrollLeft != null) {
        setScrollLeft(cm, scrollPos.scrollLeft);
        if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true; }
      }
      if (!changed) { break }
    }
    return rect
  }

// Scroll a given set of coordinates into view (immediately).
  function scrollIntoView(cm, rect) {
    var scrollPos = calculateScrollPos(cm, rect);
    if (scrollPos.scrollTop != null) { updateScrollTop(cm, scrollPos.scrollTop); }
    if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft); }
  }

// Calculate a new scroll position needed to scroll the given
  // rectangle into view. Returns an object with scrollTop and
  // scrollLeft properties. When these are undefined, the
  // vertical/horizontal position does not need to be adjusted.
  function calculateScrollPos(cm, rect) {
    var display = cm.display, snapMargin = textHeight(cm.display);
    if (rect.top < 0) { rect.top = 0; }
    var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop;
    var screen = displayHeight(cm), result = {};
    if (rect.bottom - rect.top > screen) { rect.bottom = rect.top + screen; }
    var docBottom = cm.doc.height + paddingVert(display);
    var atTop = rect.top < snapMargin, atBottom = rect.bottom > docBottom - snapMargin;
    if (rect.top < screentop) {
      result.scrollTop = atTop ? 0 : rect.top;
    } else if (rect.bottom > screentop + screen) {
      var newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen);
      if (newTop != screentop) { result.scrollTop = newTop; }
    }

// Store a relative adjustment to the scroll position in the current
  // operation (to be applied when the operation finishes).
  function addToScrollTop(cm, top) {
    if (top == null) { return }
    resolveScrollToPos(cm);
    cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top;
  }

// Make sure that at the end of the operation the current cursor is
  // shown.
  function ensureCursorVisible(cm) {
    resolveScrollToPos(cm);
    var cur = cm.getCursor();
    cm.curOp.scrollToPos = {from: cur, to: cur, margin: cm.options.cursorScrollMargin};
  }

function scrollToCoords(cm, x, y) {
    if (x != null || y != null) { resolveScrollToPos(cm); }
    if (x != null) { cm.curOp.scrollLeft = x; }
    if (y != null) { cm.curOp.scrollTop = y; }
  }

function scrollToRange(cm, range$$1) {
    resolveScrollToPos(cm);
    cm.curOp.scrollToPos = range$$1;
  }

// When an operation has its scrollToPos property set, and another
  // scroll action is applied before the end of the operation, this
  // 'simulates' scrolling that position into view in a cheap way, so
  // that the effect of intermediate scroll commands is not ignored.
  function resolveScrollToPos(cm) {
    var range$$1 = cm.curOp.scrollToPos;
    if (range$$1) {
      cm.curOp.scrollToPos = null;
      var from = estimateCoords(cm, range$$1.from), to = estimateCoords(cm, range$$1.to);
      scrollToCoordsRange(cm, from, to, range$$1.margin);
    }
  }

function scrollToCoordsRange(cm, from, to, margin) {
    var sPos = calculateScrollPos(cm, {
      left: Math.min(from.left, to.left),
      top: Math.min(from.top, to.top) - margin,
      right: Math.max(from.right, to.right),
      bottom: Math.max(from.bottom, to.bottom) + margin
    });
    scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop);
  }

// Sync the scrollable area and scrollbars, ensure the viewport
  // covers the visible area.
  function updateScrollTop(cm, val) {
    if (Math.abs(cm.doc.scrollTop - val) < 2) { return }
    if (!gecko) { updateDisplaySimple(cm, {top: val}); }
    setScrollTop(cm, val, true);
    if (gecko) { updateDisplaySimple(cm); }
    startWorker(cm, 100);
  }

// Sync scroller and scrollbar, ensure the gutter elements are
  // aligned.
  function setScrollLeft(cm, val, isScroller, forceScroll) {
    val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth);
    if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) { return }
    cm.doc.scrollLeft = val;
    alignHorizontally(cm);
    if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val; }
    cm.display.scrollbars.setScrollLeft(val);
  }

// SCROLLBARS

// Prepare DOM reads needed to update the scrollbars. Done in one
  // shot to minimize update/measure roundtrips.
  function measureForScrollbars(cm) {
    var d = cm.display, gutterW = d.gutters.offsetWidth;
    var docH = Math.round(cm.doc.height + paddingVert(cm.display));
    return {
      clientHeight: d.scroller.clientHeight,
      viewHeight: d.wrapper.clientHeight,
      scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,
      viewWidth: d.wrapper.clientWidth,
      barLeft: cm.options.fixedGutter ? gutterW : 0,
      docHeight: docH,
      scrollHeight: docH + scrollGap(cm) + d.barHeight,
      nativeBarWidth: d.nativeBarWidth,
      gutterWidth: gutterW
    }
  }

var NativeScrollbars = function(place, scroll, cm) {
    this.cm = cm;
    var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar");
    var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar");
    vert.tabIndex = horiz.tabIndex = -1;
    place(vert); place(horiz);

on(vert, "scroll", function () {
      if (vert.clientHeight) { scroll(vert.scrollTop, "vertical"); }
    });
    on(horiz, "scroll", function () {
      if (horiz.clientWidth) { scroll(horiz.scrollLeft, "horizontal"); }
    });

this.checkedZeroWidth = false;
    // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
    if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = "18px"; }
  };

NativeScrollbars.prototype.update = function (measure) {
    var needsH = measure.scrollWidth > measure.clientWidth + 1;
    var needsV = measure.scrollHeight > measure.clientHeight + 1;
    var sWidth = measure.nativeBarWidth;

if (needsV) {
      this.vert.style.display = "block";
      this.vert.style.bottom = needsH ? sWidth + "px" : "0";
      var totalHeight = measure.viewHeight - (needsH ? sWidth : 0);
      // A bug in IE8 can cause this value to be negative, so guard it.
      this.vert.firstChild.style.height =
        Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px";
    } else {
      this.vert.style.display = "";
      this.vert.firstChild.style.height = "0";
    }

if (needsH) {
      this.horiz.style.display = "block";
      this.horiz.style.right = needsV ? sWidth + "px" : "0";
      this.horiz.style.left = measure.barLeft + "px";
      var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0);
      this.horiz.firstChild.style.width =
        Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + "px";
    } else {
      this.horiz.style.display = "";
      this.horiz.firstChild.style.width = "0";
    }

if (!this.checkedZeroWidth && measure.clientHeight > 0) {
      if (sWidth == 0) { this.zeroWidthHack(); }
      this.checkedZeroWidth = true;
    }

return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0}
  };

NativeScrollbars.prototype.setScrollLeft = function (pos) {
    if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos; }
    if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz, "horiz"); }
  };

NativeScrollbars.prototype.setScrollTop = function (pos) {
    if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos; }
    if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert, "vert"); }
  };

NativeScrollbars.prototype.zeroWidthHack = function () {
    var w = mac && !mac_geMountainLion ? "12px" : "18px";
    this.horiz.style.height = this.vert.style.width = w;
    this.horiz.style.pointerEvents = this.vert.style.pointerEvents = "none";
    this.disableHoriz = new Delayed;
    this.disableVert = new Delayed;
  };

NativeScrollbars.prototype.enableZeroWidthBar = function (bar, delay, type) {
    bar.style.pointerEvents = "auto";
    function maybeDisable() {
      // To find out whether the scrollbar is still visible, we
      // check whether the element under the pixel in the bottom
      // right corner of the scrollbar box is the scrollbar box
      // itself (when the bar is still visible) or its filler child
      // (when the bar is hidden). If it is still visible, we keep
      // it enabled, if it's hidden, we disable pointer events.
      var box = bar.getBoundingClientRect();
      var elt$$1 = type == "vert" ? document.elementFromPoint(box.right - 1, (box.top + box.bottom) / 2)
          : document.elementFromPoint((box.right + box.left) / 2, box.bottom - 1);
      if (elt$$1 != bar) { bar.style.pointerEvents = "none"; }
      else { delay.set(1000, maybeDisable); }
    }
    delay.set(1000, maybeDisable);
  };

NativeScrollbars.prototype.clear = function () {
    var parent = this.horiz.parentNode;
    parent.removeChild(this.horiz);
    parent.removeChild(this.vert);
  };

var NullScrollbars = function () {};

NullScrollbars.prototype.update = function () { return {bottom: 0, right: 0} };
  NullScrollbars.prototype.setScrollLeft = function () {};
  NullScrollbars.prototype.setScrollTop = function () {};
  NullScrollbars.prototype.clear = function () {};

// Re-synchronize the fake scrollbars with the actual size of the
  // content.
  function updateScrollbarsInner(cm, measure) {
    var d = cm.display;
    var sizes = d.scrollbars.update(measure);

d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px";
    d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px";
    d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent";

if (sizes.right && sizes.bottom) {
      d.scrollbarFiller.style.display = "block";
      d.scrollbarFiller.style.height = sizes.bottom + "px";
      d.scrollbarFiller.style.width = sizes.right + "px";
    } else { d.scrollbarFiller.style.display = ""; }
    if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
      d.gutterFiller.style.display = "block";
      d.gutterFiller.style.height = sizes.bottom + "px";
      d.gutterFiller.style.width = measure.gutterWidth + "px";
    } else { d.gutterFiller.style.display = ""; }
  }

var scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars};

function initScrollbars(cm) {
    if (cm.display.scrollbars) {
      cm.display.scrollbars.clear();
      if (cm.display.scrollbars.addClass)
        { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass); }
    }

cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) {
      cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller);
      // Prevent clicks in the scrollbars from killing focus
      on(node, "mousedown", function () {
        if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0); }
      });
      node.setAttribute("cm-not-content", "true");
    }, function (pos, axis) {
      if (axis == "horizontal") { setScrollLeft(cm, pos); }
      else { updateScrollTop(cm, pos); }
    }, cm);
    if (cm.display.scrollbars.addClass)
      { addClass(cm.display.wrapper, cm.display.scrollbars.addClass); }
  }

// Operations are used to wrap a series of changes to the editor
  // state in such a way that each change won't have to update the
  // cursor and display (which would be awkward, slow, and
  // error-prone). Instead, display updates are batched and then all
  // combined and executed at once.

var nextOpId = 0;
  // Start a new operation.
  function startOperation(cm) {
    cm.curOp = {
      cm: cm,
      viewChanged: false,      // Flag that indicates that lines might need to be redrawn
      startHeight: cm.doc.height, // Used to detect need to update scrollbar
      forceUpdate: false,      // Used to force a redraw
      updateInput: 0,       // Whether to reset the input textarea
      typing: false,           // Whether this reset should be careful to leave existing text (for compositing)
      changeObjs: null,        // Accumulated changes, for firing change events
      cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on
      cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already
      selectionChanged: false, // Whether the selection needs to be redrawn
      updateMaxLine: false,    // Set when the widest line needs to be determined anew
      scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet
      scrollToPos: null,       // Used to scroll to a specific position
      focus: false,
      id: ++nextOpId           // Unique ID
    };
    pushOperation(cm.curOp);
  }

// Finish an operation, updating the display and signalling delayed events
  function endOperation(cm) {
    var op = cm.curOp;
    if (op) { finishOperation(op, function (group) {
      for (var i = 0; i < group.ops.length; i++)
        { group.ops[i].cm.curOp = null; }
      endOperations(group);
    }); }
  }

// The DOM updates done when an operation finishes are batched so
  // that the minimum number of relayouts are required.
  function endOperations(group) {
    var ops = group.ops;
    for (var i = 0; i < ops.length; i++) // Read DOM
      { endOperation_R1(ops[i]); }
    for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe)
      { endOperation_W1(ops[i$1]); }
    for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM
      { endOperation_R2(ops[i$2]); }
    for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe)
      { endOperation_W2(ops[i$3]); }
    for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM
      { endOperation_finish(ops[i$4]); }
  }

function endOperation_R1(op) {
    var cm = op.cm, display = cm.display;
    maybeClipScrollbars(cm);
    if (op.updateMaxLine) { findMaxLine(cm); }

op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||
      op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||
                         op.scrollToPos.to.line >= display.viewTo) ||
      display.maxLineChanged && cm.options.lineWrapping;
    op.update = op.mustUpdate &&
      new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate);
  }

function endOperation_W1(op) {
    op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update);
  }

function endOperation_R2(op) {
    var cm = op.cm, display = cm.display;
    if (op.updatedDisplay) { updateHeightsInViewport(cm); }

op.barMeasure = measureForScrollbars(cm);

// If the max line changed since it was last measured, measure it,
    // and ensure the document's width matches it.
    // updateDisplay_W2 will use these properties to do the actual resizing
    if (display.maxLineChanged && !cm.options.lineWrapping) {
      op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3;
      cm.display.sizerWidth = op.adjustWidthTo;
      op.barMeasure.scrollWidth =
        Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth);
      op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm));
    }

if (op.updatedDisplay || op.selectionChanged)
      { op.preparedSelection = display.input.prepareSelection(); }
  }

function endOperation_W2(op) {
    var cm = op.cm;

if (op.adjustWidthTo != null) {
      cm.display.sizer.style.minWidth = op.adjustWidthTo + "px";
      if (op.maxScrollLeft < cm.doc.scrollLeft)
        { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true); }
      cm.display.maxLineChanged = false;
    }

if (op.selectionChanged) { restartBlink(cm); }

if (cm.state.focused && op.updateInput)
      { cm.display.input.reset(op.typing); }
    if (takeFocus) { ensureFocus(op.cm); }
  }

function endOperation_finish(op) {
    var cm = op.cm, display = cm.display, doc = cm.doc;

if (op.updatedDisplay) { postUpdateDisplay(cm, op.update); }

// Abort mouse wheel delta measurement, when scrolling explicitly
    if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))
      { display.wheelStartX = display.wheelStartY = null; }

// Propagate the scroll position to the actual DOM scroller
    if (op.scrollTop != null) { setScrollTop(cm, op.scrollTop, op.forceScroll); }

if (op.scrollLeft != null) { setScrollLeft(cm, op.scrollLeft, true, true); }
    // If we need to scroll a specific position into view, do so.
    if (op.scrollToPos) {
      var rect = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),
                                   clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin);
      maybeScrollWindow(cm, rect);
    }

// Fire events for markers that are hidden/unidden by editing or
    // undoing
    var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers;
    if (hidden) { for (var i = 0; i < hidden.length; ++i)
      { if (!hidden[i].lines.length) { signal(hidden[i], "hide"); } } }
    if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1)
      { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], "unhide"); } } }

if (display.wrapper.offsetHeight)
      { doc.scrollTop = cm.display.scroller.scrollTop; }

// Fire change events, and delayed event handlers
    if (op.changeObjs)
      { signal(cm, "changes", cm, op.changeObjs); }
    if (op.update)
      { op.update.finish(); }
  }

// Run the given function in an operation
  function runInOp(cm, f) {
    if (cm.curOp) { return f() }
    startOperation(cm);
    try { return f() }
    finally { endOperation(cm); }
  }
  // Wraps a function in an operation. Returns the wrapped function.
  function operation(cm, f) {
    return function() {
      if (cm.curOp) { return f.apply(cm, arguments) }
      startOperation(cm);
      try { return f.apply(cm, arguments) }
      finally { endOperation(cm); }
    }
  }
  // Used to add methods to editor and doc instances, wrapping them in
  // operations.
  function methodOp(f) {
    return function() {
      if (this.curOp) { return f.apply(this, arguments) }
      startOperation(this);
      try { return f.apply(this, arguments) }
      finally { endOperation(this); }
    }
  }
  function docMethodOp(f) {
    return function() {
      var cm = this.cm;
      if (!cm || cm.curOp) { return f.apply(this, arguments) }
      startOperation(cm);
      try { return f.apply(this, arguments) }
      finally { endOperation(cm); }
    }
  }

// Updates the display.view data structure for a given change to the
  // document. From and to are in pre-change coordinates. Lendiff is
  // the amount of lines added or subtracted by the change. This is
  // used for changes that span multiple lines, or change the way
  // lines are divided into visual lines. regLineChange (below)
  // registers single-line changes.
  function regChange(cm, from, to, lendiff) {
    if (from == null) { from = cm.doc.first; }
    if (to == null) { to = cm.doc.first + cm.doc.size; }
    if (!lendiff) { lendiff = 0; }

var display = cm.display;
    if (lendiff && to < display.viewTo &&
        (display.updateLineNumbers == null || display.updateLineNumbers > from))
      { display.updateLineNumbers = from; }

cm.curOp.viewChanged = true;

if (from >= display.viewTo) { // Change after
      if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)
        { resetView(cm); }
    } else if (to <= display.viewFrom) { // Change before
      if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {
        resetView(cm);
      } else {
        display.viewFrom += lendiff;
        display.viewTo += lendiff;
      }
    } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap
      resetView(cm);
    } else if (from <= display.viewFrom) { // Top overlap
      var cut = viewCuttingPoint(cm, to, to + lendiff, 1);
      if (cut) {
        display.view = display.view.slice(cut.index);
        display.viewFrom = cut.lineN;
        display.viewTo += lendiff;
      } else {
        resetView(cm);
      }
    } else if (to >= display.viewTo) { // Bottom overlap
      var cut$1 = viewCuttingPoint(cm, from, from, -1);
      if (cut$1) {
        display.view = display.view.slice(0, cut$1.index);
        display.viewTo = cut$1.lineN;
      } else {
        resetView(cm);
      }
    } else { // Gap in the middle
      var cutTop = viewCuttingPoint(cm, from, from, -1);
      var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1);
      if (cutTop && cutBot) {
        display.view = display.view.slice(0, cutTop.index)
          .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
          .concat(display.view.slice(cutBot.index));
        display.viewTo += lendiff;
      } else {
        resetView(cm);
      }
    }

// Register a change to a single line. Type must be one of "text",
  // "gutter", "class", "widget"
  function regLineChange(cm, line, type) {
    cm.curOp.viewChanged = true;
    var display = cm.display, ext = cm.display.externalMeasured;
    if (ext && line >= ext.lineN && line < ext.lineN + ext.size)
      { display.externalMeasured = null; }

if (line < display.viewFrom || line >= display.viewTo) { return }
    var lineView = display.view[findViewIndex(cm, line)];
    if (lineView.node == null) { return }
    var arr = lineView.changes || (lineView.changes = []);
    if (indexOf(arr, type) == -1) { arr.push(type); }
  }

// Clear the view.
  function resetView(cm) {
    cm.display.viewFrom = cm.display.viewTo = cm.doc.first;
    cm.display.view = [];
    cm.display.viewOffset = 0;
  }

// Force the view to cover a given range, adding empty view element
  // or clipping off existing ones as needed.
  function adjustView(cm, from, to) {
    var display = cm.display, view = display.view;
    if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {
      display.view = buildViewArray(cm, from, to);
      display.viewFrom = from;
    } else {
      if (display.viewFrom > from)
        { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view); }
      else if (display.viewFrom < from)
        { display.view = display.view.slice(findViewIndex(cm, from)); }
      display.viewFrom = from;
      if (display.viewTo < to)
        { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)); }
      else if (display.viewTo > to)
        { display.view = display.view.slice(0, findViewIndex(cm, to)); }
    }
    display.viewTo = to;
  }

// Count the number of lines in the view whose DOM representation is
  // out of date (or nonexistent).
  function countDirtyView(cm) {
    var view = cm.display.view, dirty = 0;
    for (var i = 0; i < view.length; i++) {
      var lineView = view[i];
      if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty; }
    }
    return dirty
  }

// HIGHLIGHT WORKER

function startWorker(cm, time) {
    if (cm.doc.highlightFrontier < cm.display.viewTo)
      { cm.state.highlight.set(time, bind(highlightWorker, cm)); }
  }

function highlightWorker(cm) {
    var doc = cm.doc;
    if (doc.highlightFrontier >= cm.display.viewTo) { return }
    var end = +new Date + cm.options.workTime;
    var context = getContextBefore(cm, doc.highlightFrontier);
    var changedLines = [];

doc.iter(context.line, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) {
      if (context.line >= cm.display.viewFrom) { // Visible
        var oldStyles = line.styles;
        var resetState = line.text.length > cm.options.maxHighlightLength ? copyState(doc.mode, context.state) : null;
        var highlighted = highlightLine(cm, line, context, true);
        if (resetState) { context.state = resetState; }
        line.styles = highlighted.styles;
        var oldCls = line.styleClasses, newCls = highlighted.classes;
        if (newCls) { line.styleClasses = newCls; }
        else if (oldCls) { line.styleClasses = null; }
        var ischange = !oldStyles || oldStyles.length != line.styles.length ||
          oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass);
        for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i]; }
        if (ischange) { changedLines.push(context.line); }
        line.stateAfter = context.save();
        context.nextLine();
      } else {
        if (line.text.length <= cm.options.maxHighlightLength)
          { processLine(cm, line.text, context); }
        line.stateAfter = context.line % 5 == 0 ? context.save() : null;
        context.nextLine();
      }
      if (+new Date > end) {
        startWorker(cm, cm.options.workDelay);
        return true
      }
    });
    doc.highlightFrontier = context.line;
    doc.modeFrontier = Math.max(doc.modeFrontier, context.line);
    if (changedLines.length) { runInOp(cm, function () {
      for (var i = 0; i < changedLines.length; i++)
        { regLineChange(cm, changedLines[i], "text"); }
    }); }
  }

// DISPLAY DRAWING

var DisplayUpdate = function(cm, viewport, force) {
    var display = cm.display;

this.viewport = viewport;
    // Store some values that we'll need later (but don't want to force a relayout for)
    this.visible = visibleLines(display, cm.doc, viewport);
    this.editorIsHidden = !display.wrapper.offsetWidth;
    this.wrapperHeight = display.wrapper.clientHeight;
    this.wrapperWidth = display.wrapper.clientWidth;
    this.oldDisplayWidth = displayWidth(cm);
    this.force = force;
    this.dims = getDimensions(cm);
    this.events = [];
  };

DisplayUpdate.prototype.signal = function (emitter, type) {
    if (hasHandler(emitter, type))
      { this.events.push(arguments); }
  };
  DisplayUpdate.prototype.finish = function () {
      var this$1 = this;

for (var i = 0; i < this.events.length; i++)
      { signal.apply(null, this$1.events[i]); }
  };

function maybeClipScrollbars(cm) {
    var display = cm.display;
    if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
      display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth;
      display.heightForcer.style.height = scrollGap(cm) + "px";
      display.sizer.style.marginBottom = -display.nativeBarWidth + "px";
      display.sizer.style.borderRightWidth = scrollGap(cm) + "px";
      display.scrollbarsClipped = true;
    }
  }

// Does the actual updating of the line display. Bails out
  // (returning false) when there is nothing to be done and forced is
  // false.
  function updateDisplayIfNeeded(cm, update) {
    var display = cm.display, doc = cm.doc;

if (update.editorIsHidden) {
      resetView(cm);
      return false
    }

// Bail out if the visible area is already rendered and nothing changed.
    if (!update.force &&
        update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&
        (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&
        display.renderedView == display.view && countDirtyView(cm) == 0)
      { return false }

if (maybeUpdateLineNumberWidth(cm)) {
      resetView(cm);
      update.dims = getDimensions(cm);
    }

// Compute a suitable new viewport (from & to)
    var end = doc.first + doc.size;
    var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first);
    var to = Math.min(end, update.visible.to + cm.options.viewportMargin);
    if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom); }
    if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo); }
    if (sawCollapsedSpans) {
      from = visualLineNo(cm.doc, from);
      to = visualLineEndNo(cm.doc, to);
    }

var different = from != display.viewFrom || to != display.viewTo ||
      display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth;
    adjustView(cm, from, to);

display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom));
    // Position the mover div to align with the current scroll position
    cm.display.mover.style.top = display.viewOffset + "px";

var toUpdate = countDirtyView(cm);
    if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&
        (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))
      { return false }

// For big changes, we hide the enclosing element during the
    // update, since that speeds up the operations on most browsers.
    var selSnapshot = selectionSnapshot(cm);
    if (toUpdate > 4) { display.lineDiv.style.display = "none"; }
    patchDisplay(cm, display.updateLineNumbers, update.dims);
    if (toUpdate > 4) { display.lineDiv.style.display = ""; }
    display.renderedView = display.view;
    // There might have been a widget with a focused element that got
    // hidden or updated, if so re-focus it.
    restoreSelection(selSnapshot);

// Prevent selection and cursors from interfering with the scroll
    // width and height.
    removeChildren(display.cursorDiv);
    removeChildren(display.selectionDiv);
    display.gutters.style.height = display.sizer.style.minHeight = 0;

if (different) {
      display.lastWrapHeight = update.wrapperHeight;
      display.lastWrapWidth = update.wrapperWidth;
      startWorker(cm, 400);
    }

display.updateLineNumbers = null;

return true
  }

function postUpdateDisplay(cm, update) {
    var viewport = update.viewport;

for (var first = true;; first = false) {
      if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {
        // Clip forced viewport to actual scrollable area.
        if (viewport && viewport.top != null)
          { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)}; }
        // Updated line heights might result in the drawn area not
        // actually covering the viewport. Keep looping until it does.
        update.visible = visibleLines(cm.display, cm.doc, viewport);
        if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)
          { break }
      }
      if (!updateDisplayIfNeeded(cm, update)) { break }
      updateHeightsInViewport(cm);
      var barMeasure = measureForScrollbars(cm);
      updateSelection(cm);
      updateScrollbars(cm, barMeasure);
      setDocumentHeight(cm, barMeasure);
      update.force = false;
    }

update.signal(cm, "update", cm);
    if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {
      update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo);
      cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo;
    }
  }

function updateDisplaySimple(cm, viewport) {
    var update = new DisplayUpdate(cm, viewport);
    if (updateDisplayIfNeeded(cm, update)) {
      updateHeightsInViewport(cm);
      postUpdateDisplay(cm, update);
      var barMeasure = measureForScrollbars(cm);
      updateSelection(cm);
      updateScrollbars(cm, barMeasure);
      setDocumentHeight(cm, barMeasure);
      update.finish();
    }
  }

// Sync the actual display DOM structure with display.view, removing
  // nodes for lines that are no longer in view, and creating the ones
  // that are not there yet, and updating the ones that are out of
  // date.
  function patchDisplay(cm, updateNumbersFrom, dims) {
    var display = cm.display, lineNumbers = cm.options.lineNumbers;
    var container = display.lineDiv, cur = container.firstChild;

function updateGutterSpace(cm) {
    var width = cm.display.gutters.offsetWidth;
    cm.display.sizer.style.marginLeft = width + "px";
  }

function setDocumentHeight(cm, measure) {
    cm.display.sizer.style.minHeight = measure.docHeight + "px";
    cm.display.heightForcer.style.top = measure.docHeight + "px";
    cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px";
  }

// Rebuild the gutter elements, ensure the margin to the left of the
  // code matches their width.
  function updateGutters(cm) {
    var gutters = cm.display.gutters, specs = cm.options.gutters;
    removeChildren(gutters);
    var i = 0;
    for (; i < specs.length; ++i) {
      var gutterClass = specs[i];
      var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass));
      if (gutterClass == "CodeMirror-linenumbers") {
        cm.display.lineGutter = gElt;
        gElt.style.width = (cm.display.lineNumWidth || 1) + "px";
      }
    }
    gutters.style.display = i ? "" : "none";
    updateGutterSpace(cm);
  }

// Make sure the gutters options contains the element
  // "CodeMirror-linenumbers" when the lineNumbers option is true.
  function setGuttersForLineNumbers(options) {
    var found = indexOf(options.gutters, "CodeMirror-linenumbers");
    if (found == -1 && options.lineNumbers) {
      options.gutters = options.gutters.concat(["CodeMirror-linenumbers"]);
    } else if (found > -1 && !options.lineNumbers) {
      options.gutters = options.gutters.slice(0);
      options.gutters.splice(found, 1);
    }
  }

// Since the delta values reported on mouse wheel events are
  // unstandardized between browsers and even browser versions, and
  // generally horribly unpredictable, this code starts by measuring
  // the scroll effect that the first few mouse wheel events have,
  // and, from that, detects the way it can convert deltas to pixel
  // offsets afterwards.
  //
  // The reason we want to know the amount a wheel event will scroll
  // is that it gives us a chance to update the display before the
  // actual scrolling happens, reducing flickering.

function onScrollWheel(cm, e) {
    var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y;

var display = cm.display, scroll = display.scroller;
    // Quit if there's nothing to scroll here
    var canScrollX = scroll.scrollWidth > scroll.clientWidth;
    var canScrollY = scroll.scrollHeight > scroll.clientHeight;
    if (!(dx && canScrollX || dy && canScrollY)) { return }

// Webkit browsers on OS X abort momentum scrolls when the target
    // of the scroll event is removed from the scrollable element.
    // This hack (see related code in patchDisplay) makes sure the
    // element is kept around.
    if (dy && mac && webkit) {
      outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {
        for (var i = 0; i < view.length; i++) {
          if (view[i].node == cur) {
            cm.display.currentWheelTarget = cur;
            break outer
          }
        }
      }
    }

// On some browsers, horizontal scrolling will cause redraws to
    // happen before the gutter has been realigned, causing it to
    // wriggle around in a most unseemly way. When we have an
    // estimated pixels/delta value, we just handle horizontal
    // scrolling entirely here. It'll be slightly off from native, but
    // better than glitching out.
    if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {
      if (dy && canScrollY)
        { updateScrollTop(cm, Math.max(0, scroll.scrollTop + dy * wheelPixelsPerUnit)); }
      setScrollLeft(cm, Math.max(0, scroll.scrollLeft + dx * wheelPixelsPerUnit));
      // Only prevent default scrolling if vertical scrolling is
      // actually possible. Otherwise, it causes vertical scroll
      // jitter on OSX trackpads when deltaX is small and deltaY
      // is large (issue #3579)
      if (!dy || (dy && canScrollY))
        { e_preventDefault(e); }
      display.wheelStartX = null; // Abort measurement, if in progress
      return
    }

// 'Project' the visible viewport to cover the area that is being
    // scrolled into view (if we know enough to estimate it).
    if (dy && wheelPixelsPerUnit != null) {
      var pixels = dy * wheelPixelsPerUnit;
      var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight;
      if (pixels < 0) { top = Math.max(0, top + pixels - 50); }
      else { bot = Math.min(cm.doc.height, bot + pixels + 50); }
      updateDisplaySimple(cm, {top: top, bottom: bot});
    }

if (wheelSamples < 20) {
      if (display.wheelStartX == null) {
        display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop;
        display.wheelDX = dx; display.wheelDY = dy;
        setTimeout(function () {
          if (display.wheelStartX == null) { return }
          var movedX = scroll.scrollLeft - display.wheelStartX;
          var movedY = scroll.scrollTop - display.wheelStartY;
          var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
            (movedX && display.wheelDX && movedX / display.wheelDX);
          display.wheelStartX = display.wheelStartY = null;
          if (!sample) { return }
          wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1);
          ++wheelSamples;
        }, 200);
      } else {
        display.wheelDX += dx; display.wheelDY += dy;
      }
    }
  }

// Selection objects are immutable. A new one is created every time
  // the selection changes. A selection is one or more non-overlapping
  // (and non-touching) ranges, sorted, and an integer that indicates
  // which one is the primary selection (the one that's scrolled into
  // view, that getCursor returns, etc).
  var Selection = function(ranges, primIndex) {
    this.ranges = ranges;
    this.primIndex = primIndex;
  };

Selection.prototype.primary = function () { return this.ranges[this.primIndex] };

Selection.prototype.equals = function (other) {
      var this$1 = this;

if (other == this) { return true }
    if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false }
    for (var i = 0; i < this.ranges.length; i++) {
      var here = this$1.ranges[i], there = other.ranges[i];
      if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) { return false }
    }
    return true
  };

Selection.prototype.deepCopy = function () {
      var this$1 = this;

var out = [];
    for (var i = 0; i < this.ranges.length; i++)
      { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)); }
    return new Selection(out, this.primIndex)
  };

Selection.prototype.somethingSelected = function () {
      var this$1 = this;

for (var i = 0; i < this.ranges.length; i++)
      { if (!this$1.ranges[i].empty()) { return true } }
    return false
  };

Selection.prototype.contains = function (pos, end) {
      var this$1 = this;

if (!end) { end = pos; }
    for (var i = 0; i < this.ranges.length; i++) {
      var range = this$1.ranges[i];
      if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)
        { return i }
    }
    return -1
  };

var Range = function(anchor, head) {
    this.anchor = anchor; this.head = head;
  };

Range.prototype.from = function () { return minPos(this.anchor, this.head) };
  Range.prototype.to = function () { return maxPos(this.anchor, this.head) };
  Range.prototype.empty = function () { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch };

// Take an unsorted, potentially overlapping set of ranges, and
  // build a selection out of it. 'Consumes' ranges array (modifying
  // it).
  function normalizeSelection(cm, ranges, primIndex) {
    var mayTouch = cm && cm.options.selectionsMayTouch;
    var prim = ranges[primIndex];
    ranges.sort(function (a, b) { return cmp(a.from(), b.from()); });
    primIndex = indexOf(ranges, prim);
    for (var i = 1; i < ranges.length; i++) {
      var cur = ranges[i], prev = ranges[i - 1];
      var diff = cmp(prev.to(), cur.from());
      if (mayTouch && !cur.empty() ? diff > 0 : diff >= 0) {
        var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to());
        var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head;
        if (i <= primIndex) { --primIndex; }
        ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to));
      }
    }
    return new Selection(ranges, primIndex)
  }

function simpleSelection(anchor, head) {
    return new Selection([new Range(anchor, head || anchor)], 0)
  }

// Compute the position of the end of a change (its 'to' property
  // refers to the pre-change end).
  function changeEnd(change) {
    if (!change.text) { return change.to }
    return Pos(change.from.line + change.text.length - 1,
               lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0))
  }

// Adjust a position to refer to the post-change position of the
  // same text, or the end of the change if the change covers it.
  function adjustForChange(pos, change) {
    if (cmp(pos, change.from) < 0) { return pos }
    if (cmp(pos, change.to) <= 0) { return changeEnd(change) }

var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch;
    if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch; }
    return Pos(line, ch)
  }

function computeSelAfterChange(doc, change) {
    var out = [];
    for (var i = 0; i < doc.sel.ranges.length; i++) {
      var range = doc.sel.ranges[i];
      out.push(new Range(adjustForChange(range.anchor, change),
                         adjustForChange(range.head, change)));
    }
    return normalizeSelection(doc.cm, out, doc.sel.primIndex)
  }

function offsetPos(pos, old, nw) {
    if (pos.line == old.line)
      { return Pos(nw.line, pos.ch - old.ch + nw.ch) }
    else
      { return Pos(nw.line + (pos.line - old.line), pos.ch) }
  }

// Used by replaceSelections to allow moving the selection to the
  // start or around the replaced test. Hint may be "start" or "around".
  function computeReplacedSel(doc, changes, hint) {
    var out = [];
    var oldPrev = Pos(doc.first, 0), newPrev = oldPrev;
    for (var i = 0; i < changes.length; i++) {
      var change = changes[i];
      var from = offsetPos(change.from, oldPrev, newPrev);
      var to = offsetPos(changeEnd(change), oldPrev, newPrev);
      oldPrev = change.to;
      newPrev = to;
      if (hint == "around") {
        var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0;
        out[i] = new Range(inv ? to : from, inv ? from : to);
      } else {
        out[i] = new Range(from, from);
      }
    }
    return new Selection(out, doc.sel.primIndex)
  }

// Used to get the editor into a consistent state again when options change.

function loadMode(cm) {
    cm.doc.mode = getMode(cm.options, cm.doc.modeOption);
    resetModeState(cm);
  }

// DOCUMENT DATA STRUCTURE

// By default, updates that start and end at the beginning of a line
  // are treated specially, in order to make the association of line
  // widgets and marker elements with the text behave more intuitive.
  function isWholeLineUpdate(doc, change) {
    return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" &&
      (!doc.cm || doc.cm.options.wholeLineUpdateBefore)
  }

// Perform a change on the document data structure.
  function updateDoc(doc, change, markedSpans, estimateHeight$$1) {
    function spansFor(n) {return markedSpans ? markedSpans[n] : null}
    function update(line, text, spans) {
      updateLine(line, text, spans, estimateHeight$$1);
      signalLater(line, "change", line, change);
    }
    function linesFor(start, end) {
      var result = [];
      for (var i = start; i < end; ++i)
        { result.push(new Line(text[i], spansFor(i), estimateHeight$$1)); }
      return result
    }

var from = change.from, to = change.to, text = change.text;
    var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line);
    var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line;

// Adjust the line structure
    if (change.full) {
      doc.insert(0, linesFor(0, text.length));
      doc.remove(text.length, doc.size - text.length);
    } else if (isWholeLineUpdate(doc, change)) {
      // This is a whole-line replace. Treated specially to make
      // sure line objects move the way they are supposed to.
      var added = linesFor(0, text.length - 1);
      update(lastLine, lastLine.text, lastSpans);
      if (nlines) { doc.remove(from.line, nlines); }
      if (added.length) { doc.insert(from.line, added); }
    } else if (firstLine == lastLine) {
      if (text.length == 1) {
        update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans);
      } else {
        var added$1 = linesFor(1, text.length - 1);
        added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight$$1));
        update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));
        doc.insert(from.line + 1, added$1);
      }
    } else if (text.length == 1) {
      update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0));
      doc.remove(from.line + 1, nlines);
    } else {
      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));
      update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans);
      var added$2 = linesFor(1, text.length - 1);
      if (nlines > 1) { doc.remove(from.line + 1, nlines - 1); }
      doc.insert(from.line + 1, added$2);
    }

signalLater(doc, "change", doc, change);
  }

// Call f for all linked documents.
  function linkedDocs(doc, f, sharedHistOnly) {
    function propagate(doc, skip, sharedHist) {
      if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) {
        var rel = doc.linked[i];
        if (rel.doc == skip) { continue }
        var shared = sharedHist && rel.sharedHist;
        if (sharedHistOnly && !shared) { continue }
        f(rel.doc, shared);
        propagate(rel.doc, doc, shared);
      } }
    }
    propagate(doc, null, true);
  }

// Attach a document to an editor.
  function attachDoc(cm, doc) {
    if (doc.cm) { throw new Error("This document is already in use.") }
    cm.doc = doc;
    doc.cm = cm;
    estimateLineHeights(cm);
    loadMode(cm);
    setDirectionClass(cm);
    if (!cm.options.lineWrapping) { findMaxLine(cm); }
    cm.options.mode = doc.modeOption;
    regChange(cm);
  }

function setDirectionClass(cm) {
  (cm.doc.direction == "rtl" ? addClass : rmClass)(cm.display.lineDiv, "CodeMirror-rtl");
  }

function directionChanged(cm) {
    runInOp(cm, function () {
      setDirectionClass(cm);
      regChange(cm);
    });
  }

function History(startGen) {
    // Arrays of change events and selections. Doing something adds an
    // event to done and clears undo. Undoing moves events from done
    // to undone, redoing moves them in the other direction.
    this.done = []; this.undone = [];
    this.undoDepth = Infinity;
    // Used to track when changes can be merged into a single undo
    // event
    this.lastModTime = this.lastSelTime = 0;
    this.lastOp = this.lastSelOp = null;
    this.lastOrigin = this.lastSelOrigin = null;
    // Used by the isClean() method
    this.generation = this.maxGeneration = startGen || 1;
  }

// Create a history change event from an updateDoc-style change
  // object.
  function historyChangeFromChange(doc, change) {
    var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)};
    attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);
    linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true);
    return histChange
  }

// Pop all selection events off the end of a history array. Stop at
  // a change event.
  function clearSelectionEvents(array) {
    while (array.length) {
      var last = lst(array);
      if (last.ranges) { array.pop(); }
      else { break }
    }
  }

// Find the top change event in the history. Pop off selection
  // events that are in the way.
  function lastChangeEvent(hist, force) {
    if (force) {
      clearSelectionEvents(hist.done);
      return lst(hist.done)
    } else if (hist.done.length && !lst(hist.done).ranges) {
      return lst(hist.done)
    } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {
      hist.done.pop();
      return lst(hist.done)
    }
  }

// Register a change in the history. Merges changes that are within
  // a single operation, or are close together with an origin that
  // allows merging (starting with "+") into a single event.
  function addChangeToHistory(doc, change, selAfter, opId) {
    var hist = doc.history;
    hist.undone.length = 0;
    var time = +new Date, cur;
    var last;

if ((hist.lastOp == opId ||
         hist.lastOrigin == change.origin && change.origin &&
         ((change.origin.charAt(0) == "+" && hist.lastModTime > time - (doc.cm ? doc.cm.options.historyEventDelay : 500)) ||
          change.origin.charAt(0) == "*")) &&
        (cur = lastChangeEvent(hist, hist.lastOp == opId))) {
      // Merge this change into the last event
      last = lst(cur.changes);
      if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {
        // Optimized case for simple insertion -- don't want to add
        // new changesets for every character typed
        last.to = changeEnd(change);
      } else {
        // Add new sub-event
        cur.changes.push(historyChangeFromChange(doc, change));
      }
    } else {
      // Can not be merged, start a new event.
      var before = lst(hist.done);
      if (!before || !before.ranges)
        { pushSelectionToHistory(doc.sel, hist.done); }
      cur = {changes: [historyChangeFromChange(doc, change)],
             generation: hist.generation};
      hist.done.push(cur);
      while (hist.done.length > hist.undoDepth) {
        hist.done.shift();
        if (!hist.done[0].ranges) { hist.done.shift(); }
      }
    }
    hist.done.push(selAfter);
    hist.generation = ++hist.maxGeneration;
    hist.lastModTime = hist.lastSelTime = time;
    hist.lastOp = hist.lastSelOp = opId;
    hist.lastOrigin = hist.lastSelOrigin = change.origin;

if (!last) { signal(doc, "historyAdded"); }
  }

function selectionEventCanBeMerged(doc, origin, prev, sel) {
    var ch = origin.charAt(0);
    return ch == "*" ||
      ch == "+" &&
      prev.ranges.length == sel.ranges.length &&
      prev.somethingSelected() == sel.somethingSelected() &&
      new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500)
  }

// Called whenever the selection changes, sets the new selection as
  // the pending selection in the history, and pushes the old pending
  // selection into the 'done' array when it was significantly
  // different (in number of selected ranges, emptiness, or time).
  function addSelectionToHistory(doc, sel, opId, options) {
    var hist = doc.history, origin = options && options.origin;

// A new event is started when the previous origin does not match
    // the current, or the origins don't allow matching. Origins
    // starting with * are always merged, those starting with + are
    // merged when similar and close together in time.
    if (opId == hist.lastSelOp ||
        (origin && hist.lastSelOrigin == origin &&
         (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||
          selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))
      { hist.done[hist.done.length - 1] = sel; }
    else
      { pushSelectionToHistory(sel, hist.done); }

hist.lastSelTime = +new Date;
    hist.lastSelOrigin = origin;
    hist.lastSelOp = opId;
    if (options && options.clearRedo !== false)
      { clearSelectionEvents(hist.undone); }
  }

function pushSelectionToHistory(sel, dest) {
    var top = lst(dest);
    if (!(top && top.ranges && top.equals(sel)))
      { dest.push(sel); }
  }

// Used to store marked span information in the history.
  function attachLocalSpans(doc, change, from, to) {
    var existing = change["spans_" + doc.id], n = 0;
    doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) {
      if (line.markedSpans)
        { (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans; }
      ++n;
    });
  }

// When un/re-doing restores text containing marked spans, those
  // that have been explicitly cleared should not be restored.
  function removeClearedSpans(spans) {
    if (!spans) { return null }
    var out;
    for (var i = 0; i < spans.length; ++i) {
      if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i); } }
      else if (out) { out.push(spans[i]); }
    }
    return !out ? spans : out.length ? out : null
  }

// Retrieve and filter the old marked spans stored in a change event.
  function getOldSpans(doc, change) {
    var found = change["spans_" + doc.id];
    if (!found) { return null }
    var nw = [];
    for (var i = 0; i < change.text.length; ++i)
      { nw.push(removeClearedSpans(found[i])); }
    return nw
  }

// Used for un/re-doing changes from the history. Combines the
  // result of computing the existing spans with the set of spans that
  // existed in the history (so that deleting around a span and then
  // undoing brings back the span).
  function mergeOldSpans(doc, change) {
    var old = getOldSpans(doc, change);
    var stretched = stretchSpansOverChange(doc, change);
    if (!old) { return stretched }
    if (!stretched) { return old }

for (var i = 0; i < old.length; ++i) {
      var oldCur = old[i], stretchCur = stretched[i];
      if (oldCur && stretchCur) {
        spans: for (var j = 0; j < stretchCur.length; ++j) {
          var span = stretchCur[j];
          for (var k = 0; k < oldCur.length; ++k)
            { if (oldCur[k].marker == span.marker) { continue spans } }
          oldCur.push(span);
        }
      } else if (stretchCur) {
        old[i] = stretchCur;
      }
    }
    return old
  }

// Used both to provide a JSON-safe object in .getHistory, and, when
  // detaching a document, to split the history in two
  function copyHistoryArray(events, newGroup, instantiateSel) {
    var copy = [];
    for (var i = 0; i < events.length; ++i) {
      var event = events[i];
      if (event.ranges) {
        copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event);
        continue
      }
      var changes = event.changes, newChanges = [];
      copy.push({changes: newChanges});
      for (var j = 0; j < changes.length; ++j) {
        var change = changes[j], m = (void 0);
        newChanges.push({from: change.from, to: change.to, text: change.text});
        if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\d+)$/)) {
          if (indexOf(newGroup, Number(m[1])) > -1) {
            lst(newChanges)[prop] = change[prop];
            delete change[prop];
          }
        } } }
      }
    }
    return copy
  }

// The 'scroll' parameter given to many of these indicated whether
  // the new cursor position should be scrolled into view after
  // modifying the selection.

// If shift is held or the extend flag is set, extends a range to
  // include a given position (and optionally a second position).
  // Otherwise, simply returns the range between the given positions.
  // Used for cursor motion and such.
  function extendRange(range, head, other, extend) {
    if (extend) {
      var anchor = range.anchor;
      if (other) {
        var posBefore = cmp(head, anchor) < 0;
        if (posBefore != (cmp(other, anchor) < 0)) {
          anchor = head;
          head = other;
        } else if (posBefore != (cmp(head, other) < 0)) {
          head = other;
        }
      }
      return new Range(anchor, head)
    } else {
      return new Range(other || head, head)
    }
  }

// Extend the primary selection range, discard the rest.
  function extendSelection(doc, head, other, options, extend) {
    if (extend == null) { extend = doc.cm && (doc.cm.display.shift || doc.extend); }
    setSelection(doc, new Selection([extendRange(doc.sel.primary(), head, other, extend)], 0), options);
  }

// Extend all selections (pos is an array of selections with length
  // equal the number of selections)
  function extendSelections(doc, heads, options) {
    var out = [];
    var extend = doc.cm && (doc.cm.display.shift || doc.extend);
    for (var i = 0; i < doc.sel.ranges.length; i++)
      { out[i] = extendRange(doc.sel.ranges[i], heads[i], null, extend); }
    var newSel = normalizeSelection(doc.cm, out, doc.sel.primIndex);
    setSelection(doc, newSel, options);
  }

// Updates a single range in the selection.
  function replaceOneSelection(doc, i, range, options) {
    var ranges = doc.sel.ranges.slice(0);
    ranges[i] = range;
    setSelection(doc, normalizeSelection(doc.cm, ranges, doc.sel.primIndex), options);
  }

// Reset the selection to a single range.
  function setSimpleSelection(doc, anchor, head, options) {
    setSelection(doc, simpleSelection(anchor, head), options);
  }

// Give beforeSelectionChange handlers a change to influence a
  // selection update.
  function filterSelectionChange(doc, sel, options) {
    var obj = {
      ranges: sel.ranges,
      update: function(ranges) {
        var this$1 = this;

this.ranges = [];
        for (var i = 0; i < ranges.length; i++)
          { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),
                                     clipPos(doc, ranges[i].head)); }
      },
      origin: options && options.origin
    };
    signal(doc, "beforeSelectionChange", doc, obj);
    if (doc.cm) { signal(doc.cm, "beforeSelectionChange", doc.cm, obj); }
    if (obj.ranges != sel.ranges) { return normalizeSelection(doc.cm, obj.ranges, obj.ranges.length - 1) }
    else { return sel }
  }

// Set a new selection.
  function setSelection(doc, sel, options) {
    setSelectionNoUndo(doc, sel, options);
    addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options);
  }

function setSelectionNoUndo(doc, sel, options) {
    if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange"))
      { sel = filterSelectionChange(doc, sel, options); }

var bias = options && options.bias ||
      (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1);
    setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true));

if (!(options && options.scroll === false) && doc.cm)
      { ensureCursorVisible(doc.cm); }
  }

function setSelectionInner(doc, sel) {
    if (sel.equals(doc.sel)) { return }

doc.sel = sel;

if (doc.cm) {
      doc.cm.curOp.updateInput = 1;
      doc.cm.curOp.selectionChanged = true;
      signalCursorActivity(doc.cm);
    }
    signalLater(doc, "cursorActivity", doc);
  }

// Verify that the selection does not partially select any atomic
  // marked ranges.
  function reCheckSelection(doc) {
    setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false));
  }

// Return a selection that does not partially select any atomic
  // ranges.
  function skipAtomicInSelection(doc, sel, bias, mayClear) {
    var out;
    for (var i = 0; i < sel.ranges.length; i++) {
      var range = sel.ranges[i];
      var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i];
      var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear);
      var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear);
      if (out || newAnchor != range.anchor || newHead != range.head) {
        if (!out) { out = sel.ranges.slice(0, i); }
        out[i] = new Range(newAnchor, newHead);
      }
    }
    return out ? normalizeSelection(doc.cm, out, sel.primIndex) : sel
  }

if (oldPos) {
          var near = m.find(dir < 0 ? 1 : -1), diff = (void 0);
          if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft)
            { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null); }
          if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0))
            { return skipAtomicInner(doc, near, pos, dir, mayClear) }
        }

var far = m.find(dir < 0 ? -1 : 1);
        if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight)
          { far = movePos(doc, far, dir, far.line == pos.line ? line : null); }
        return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null
      }
    } }
    return pos
  }

// Ensure a given position is not inside an atomic range.
  function skipAtomic(doc, pos, oldPos, bias, mayClear) {
    var dir = bias || 1;
    var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||
        (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||
        skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||
        (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true));
    if (!found) {
      doc.cantEdit = true;
      return Pos(doc.first, 0)
    }
    return found
  }

function movePos(doc, pos, dir, line) {
    if (dir < 0 && pos.ch == 0) {
      if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) }
      else { return null }
    } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {
      if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) }
      else { return null }
    } else {
      return new Pos(pos.line, pos.ch + dir)
    }
  }

function selectAll(cm) {
    cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll);
  }

// UPDATING

// Allow "beforeChange" event handlers to influence a change
  function filterChange(doc, change, update) {
    var obj = {
      canceled: false,
      from: change.from,
      to: change.to,
      text: change.text,
      origin: change.origin,
      cancel: function () { return obj.canceled = true; }
    };
    if (update) { obj.update = function (from, to, text, origin) {
      if (from) { obj.from = clipPos(doc, from); }
      if (to) { obj.to = clipPos(doc, to); }
      if (text) { obj.text = text; }
      if (origin !== undefined) { obj.origin = origin; }
    }; }
    signal(doc, "beforeChange", doc, obj);
    if (doc.cm) { signal(doc.cm, "beforeChange", doc.cm, obj); }

if (obj.canceled) {
      if (doc.cm) { doc.cm.curOp.updateInput = 2; }
      return null
    }
    return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}
  }

// Apply a change to a document, and add it to the document's
  // history, and propagating it to all linked documents.
  function makeChange(doc, change, ignoreReadOnly) {
    if (doc.cm) {
      if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) }
      if (doc.cm.state.suppressEdits) { return }
    }

if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
      change = filterChange(doc, change, true);
      if (!change) { return }
    }

// Possibly split or suppress the update based on the presence
    // of read-only spans in its range.
    var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to);
    if (split) {
      for (var i = split.length - 1; i >= 0; --i)
        { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text, origin: change.origin}); }
    } else {
      makeChangeInner(doc, change);
    }
  }

function makeChangeInner(doc, change) {
    if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) { return }
    var selAfter = computeSelAfterChange(doc, change);
    addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN);

makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change));
    var rebased = [];

linkedDocs(doc, function (doc, sharedHist) {
      if (!sharedHist && indexOf(rebased, doc.history) == -1) {
        rebaseHist(doc.history, change);
        rebased.push(doc.history);
      }
      makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change));
    });
  }

// Revert a change stored in a document's history.
  function makeChangeFromHistory(doc, type, allowSelectionOnly) {
    var suppress = doc.cm && doc.cm.state.suppressEdits;
    if (suppress && !allowSelectionOnly) { return }

var hist = doc.history, event, selAfter = doc.sel;
    var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done;

// Verify that there is a useable event (so that ctrl-z won't
    // needlessly clear selection events)
    var i = 0;
    for (; i < source.length; i++) {
      event = source[i];
      if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
        { break }
    }
    if (i == source.length) { return }
    hist.lastOrigin = hist.lastSelOrigin = null;

for (;;) {
      event = source.pop();
      if (event.ranges) {
        pushSelectionToHistory(event, dest);
        if (allowSelectionOnly && !event.equals(doc.sel)) {
          setSelection(doc, event, {clearRedo: false});
          return
        }
        selAfter = event;
      } else if (suppress) {
        source.push(event);
        return
      } else { break }
    }

// Build up a reverse change object to add to the opposite history
    // stack (redo when undoing, and vice versa).
    var antiChanges = [];
    pushSelectionToHistory(selAfter, dest);
    dest.push({changes: antiChanges, generation: hist.generation});
    hist.generation = event.generation || ++hist.maxGeneration;

var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange");

var loop = function ( i ) {
      var change = event.changes[i];
      change.origin = type;
      if (filter && !filterChange(doc, change, false)) {
        source.length = 0;
        return {}
      }

antiChanges.push(historyChangeFromChange(doc, change));

var after = i ? computeSelAfterChange(doc, change) : lst(source);
      makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change));
      if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}); }
      var rebased = [];

// Propagate to the linked documents
      linkedDocs(doc, function (doc, sharedHist) {
        if (!sharedHist && indexOf(rebased, doc.history) == -1) {
          rebaseHist(doc.history, change);
          rebased.push(doc.history);
        }
        makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change));
      });
    };

for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) {
      var returned = loop( i$1 );

if ( returned ) return returned.v;
    }
  }

// Sub-views need their line numbers shifted when text is added
  // above or below them in the parent document.
  function shiftDoc(doc, distance) {
    if (distance == 0) { return }
    doc.first += distance;
    doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range(
      Pos(range.anchor.line + distance, range.anchor.ch),
      Pos(range.head.line + distance, range.head.ch)
    ); }), doc.sel.primIndex);
    if (doc.cm) {
      regChange(doc.cm, doc.first, doc.first - distance, distance);
      for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
        { regLineChange(doc.cm, l, "gutter"); }
    }
  }

// More lower-level change function, handling only a single document
  // (not linked ones).
  function makeChangeSingleDoc(doc, change, selAfter, spans) {
    if (doc.cm && !doc.cm.curOp)
      { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) }

if (change.to.line < doc.first) {
      shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line));
      return
    }
    if (change.from.line > doc.lastLine()) { return }

// Clip the change to the size of this doc
    if (change.from.line < doc.first) {
      var shift = change.text.length - 1 - (doc.first - change.from.line);
      shiftDoc(doc, shift);
      change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
                text: [lst(change.text)], origin: change.origin};
    }
    var last = doc.lastLine();
    if (change.to.line > last) {
      change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
                text: [change.text[0]], origin: change.origin};
    }

change.removed = getBetween(doc, change.from, change.to);

if (!selAfter) { selAfter = computeSelAfterChange(doc, change); }
    if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans); }
    else { updateDoc(doc, change, spans); }
    setSelectionNoUndo(doc, selAfter, sel_dontScroll);
  }

// Handle the interaction of a change to a document with the editor
  // that this document is part of.
  function makeChangeSingleDocInEditor(cm, change, spans) {
    var doc = cm.doc, display = cm.display, from = change.from, to = change.to;

if (doc.sel.contains(change.from, change.to) > -1)
      { signalCursorActivity(cm); }

updateDoc(doc, change, spans, estimateHeight(cm));

if (!cm.options.lineWrapping) {
      doc.iter(checkWidthStart, from.line + change.text.length, function (line) {
        var len = lineLength(line);
        if (len > display.maxLineLength) {
          display.maxLine = line;
          display.maxLineLength = len;
          display.maxLineChanged = true;
          recomputeMaxLength = false;
        }
      });
      if (recomputeMaxLength) { cm.curOp.updateMaxLine = true; }
    }

retreatFrontier(doc, from.line);
    startWorker(cm, 400);

function replaceRange(doc, code, from, to, origin) {
    var assign;

if (!to) { to = from; }
    if (cmp(to, from) < 0) { (assign = [to, from], from = assign[0], to = assign[1]); }
    if (typeof code == "string") { code = doc.splitLines(code); }
    makeChange(doc, {from: from, to: to, text: code, origin: origin});
  }

// Rebasing/resetting history to deal with externally-sourced changes

function rebaseHistSelSingle(pos, from, to, diff) {
    if (to < pos.line) {
      pos.line += diff;
    } else if (from < pos.line) {
      pos.line = from;
      pos.ch = 0;
    }
  }

// Tries to rebase an array of history events given a change in the
  // document. If the change touches the same lines as the event, the
  // event, and everything 'behind' it, is discarded. If the change is
  // before the event, the event's positions are updated. Uses a
  // copy-on-write scheme for the positions, to avoid having to
  // reallocate them all on every rebase, but also avoid problems with
  // shared position objects being unsafely updated.
  function rebaseHistArray(array, from, to, diff) {
    for (var i = 0; i < array.length; ++i) {
      var sub = array[i], ok = true;
      if (sub.ranges) {
        if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true; }
        for (var j = 0; j < sub.ranges.length; j++) {
          rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff);
          rebaseHistSelSingle(sub.ranges[j].head, from, to, diff);
        }
        continue
      }
      for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) {
        var cur = sub.changes[j$1];
        if (to < cur.from.line) {
          cur.from = Pos(cur.from.line + diff, cur.from.ch);
          cur.to = Pos(cur.to.line + diff, cur.to.ch);
        } else if (from <= cur.to.line) {
          ok = false;
          break
        }
      }
      if (!ok) {
        array.splice(0, i + 1);
        i = 0;
      }
    }
  }

function rebaseHist(hist, change) {
    var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1;
    rebaseHistArray(hist.done, from, to, diff);
    rebaseHistArray(hist.undone, from, to, diff);
  }

// Utility for applying a change to a line by handle or number,
  // returning the number and optionally registering the line as
  // changed.
  function changeLine(doc, handle, changeType, op) {
    var no = handle, line = handle;
    if (typeof handle == "number") { line = getLine(doc, clipLine(doc, handle)); }
    else { no = lineNo(handle); }
    if (no == null) { return null }
    if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType); }
    return line
  }

// The document is represented as a BTree consisting of leaves, with
  // chunk of lines in them, and branches, with up to ten leaves or
  // other branch nodes below them. The top node is always a branch
  // node, and is the document object itself (meaning it has
  // additional methods and properties).
  //
  // All nodes have parent links. The tree is used both to go from
  // line numbers to line objects, and to go from objects to numbers.
  // It also indexes by height, and is used to convert between height
  // and line object, and to find the total height of the document.
  //
  // See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html

function LeafChunk(lines) {
    var this$1 = this;

this.lines = lines;
    this.parent = null;
    var height = 0;
    for (var i = 0; i < lines.length; ++i) {
      lines[i].parent = this$1;
      height += lines[i].height;
    }
    this.height = height;
  }

LeafChunk.prototype = {
    chunkSize: function() { return this.lines.length },

// Remove the n lines at offset 'at'.
    removeInner: function(at, n) {
      var this$1 = this;

for (var i = at, e = at + n; i < e; ++i) {
        var line = this$1.lines[i];
        this$1.height -= line.height;
        cleanUpLine(line);
        signalLater(line, "delete");
      }
      this.lines.splice(at, n);
    },

// Helper used to collapse a small branch into a single leaf.
    collapse: function(lines) {
      lines.push.apply(lines, this.lines);
    },

// Insert the given array of lines at offset 'at', count them as
    // having the given height.
    insertInner: function(at, lines, height) {
      var this$1 = this;

this.height += height;
      this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at));
      for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1; }
    },

// Used to iterate over a part of the tree.
    iterN: function(at, n, op) {
      var this$1 = this;

for (var e = at + n; at < e; ++at)
        { if (op(this$1.lines[at])) { return true } }
    }
  };

function BranchChunk(children) {
    var this$1 = this;

this.children = children;
    var size = 0, height = 0;
    for (var i = 0; i < children.length; ++i) {
      var ch = children[i];
      size += ch.chunkSize(); height += ch.height;
      ch.parent = this$1;
    }
    this.size = size;
    this.height = height;
    this.parent = null;
  }

BranchChunk.prototype = {
    chunkSize: function() { return this.size },

removeInner: function(at, n) {
      var this$1 = this;

this.size -= n;
      for (var i = 0; i < this.children.length; ++i) {
        var child = this$1.children[i], sz = child.chunkSize();
        if (at < sz) {
          var rm = Math.min(n, sz - at), oldHeight = child.height;
          child.removeInner(at, rm);
          this$1.height -= oldHeight - child.height;
          if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null; }
          if ((n -= rm) == 0) { break }
          at = 0;
        } else { at -= sz; }
      }
      // If the result is smaller than 25 lines, ensure that it is a
      // single leaf node.
      if (this.size - n < 25 &&
          (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
        var lines = [];
        this.collapse(lines);
        this.children = [new LeafChunk(lines)];
        this.children[0].parent = this;
      }
    },

collapse: function(lines) {
      var this$1 = this;

for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines); }
    },

insertInner: function(at, lines, height) {
      var this$1 = this;

this.size += lines.length;
      this.height += height;
      for (var i = 0; i < this.children.length; ++i) {
        var child = this$1.children[i], sz = child.chunkSize();
        if (at <= sz) {
          child.insertInner(at, lines, height);
          if (child.lines && child.lines.length > 50) {
            // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.
            // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.
            var remaining = child.lines.length % 25 + 25;
            for (var pos = remaining; pos < child.lines.length;) {
              var leaf = new LeafChunk(child.lines.slice(pos, pos += 25));
              child.height -= leaf.height;
              this$1.children.splice(++i, 0, leaf);
              leaf.parent = this$1;
            }
            child.lines = child.lines.slice(0, remaining);
            this$1.maybeSpill();
          }
          break
        }
        at -= sz;
      }
    },

// When a node has grown, check whether it should be split.
    maybeSpill: function() {
      if (this.children.length <= 10) { return }
      var me = this;
      do {
        var spilled = me.children.splice(me.children.length - 5, 5);
        var sibling = new BranchChunk(spilled);
        if (!me.parent) { // Become the parent node
          var copy = new BranchChunk(me.children);
          copy.parent = me;
          me.children = [copy, sibling];
          me = copy;
       } else {
          me.size -= sibling.size;
          me.height -= sibling.height;
          var myIndex = indexOf(me.parent.children, me);
          me.parent.children.splice(myIndex + 1, 0, sibling);
        }
        sibling.parent = me.parent;
      } while (me.children.length > 10)
      me.parent.maybeSpill();
    },

iterN: function(at, n, op) {
      var this$1 = this;

for (var i = 0; i < this.children.length; ++i) {
        var child = this$1.children[i], sz = child.chunkSize();
        if (at < sz) {
          var used = Math.min(n, sz - at);
          if (child.iterN(at, used, op)) { return true }
          if ((n -= used) == 0) { break }
          at = 0;
        } else { at -= sz; }
      }
    }
  };

// Line widgets are block elements displayed above or below a line.

var LineWidget = function(doc, node, options) {
    var this$1 = this;

if (options) { for (var opt in options) { if (options.hasOwnProperty(opt))
      { this$1[opt] = options[opt]; } } }
    this.doc = doc;
    this.node = node;
  };

LineWidget.prototype.clear = function () {
      var this$1 = this;

LineWidget.prototype.changed = function () {
      var this$1 = this;

function adjustScrollWhenAboveVisible(cm, line, diff) {
    if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))
      { addToScrollTop(cm, diff); }
  }

// TEXTMARKERS

// Created with markText and setBookmark methods. A TextMarker is a
  // handle that can be used to clear or find a marked position in the
  // document. Line objects hold arrays (markedSpans) containing
  // {from, to, marker} object pointing to such marker objects, and
  // indicating that such a marker is present on that line. Multiple
  // lines may point to the same marker when it spans across lines.
  // The spans will have null for their from/to properties when the
  // marker continues beyond the start/end of the line. Markers have
  // links back to the lines they currently touch.

// Collapsed markers have unique ids, in order to be able to order
  // them, which is needed for uniquely determining an outer marker
  // when they overlap (they may nest, but not partially overlap).
  var nextMarkerId = 0;

var TextMarker = function(doc, type) {
    this.lines = [];
    this.type = type;
    this.doc = doc;
    this.id = ++nextMarkerId;
  };

// Clear the marker.
  TextMarker.prototype.clear = function () {
      var this$1 = this;

if (this.explicitlyCleared) { return }
    var cm = this.doc.cm, withOp = cm && !cm.curOp;
    if (withOp) { startOperation(cm); }
    if (hasHandler(this, "clear")) {
      var found = this.find();
      if (found) { signalLater(this, "clear", found.from, found.to); }
    }
    var min = null, max = null;
    for (var i = 0; i < this.lines.length; ++i) {
      var line = this$1.lines[i];
      var span = getMarkedSpanFor(line.markedSpans, this$1);
      if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), "text"); }
      else if (cm) {
        if (span.to != null) { max = lineNo(line); }
        if (span.from != null) { min = lineNo(line); }
      }
      line.markedSpans = removeMarkedSpan(line.markedSpans, span);
      if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm)
        { updateLineHeight(line, textHeight(cm.display)); }
    }
    if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) {
      var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual);
      if (len > cm.display.maxLineLength) {
        cm.display.maxLine = visual;
        cm.display.maxLineLength = len;
        cm.display.maxLineChanged = true;
      }
    } }

if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1); }
    this.lines.length = 0;
    this.explicitlyCleared = true;
    if (this.atomic && this.doc.cantEdit) {
      this.doc.cantEdit = false;
      if (cm) { reCheckSelection(cm.doc); }
    }
    if (cm) { signalLater(cm, "markerCleared", cm, this, min, max); }
    if (withOp) { endOperation(cm); }
    if (this.parent) { this.parent.clear(); }
  };

// Find the position of the marker in the document. Returns a {from,
  // to} object by default. Side can be passed to get a specific side
  // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the
  // Pos objects returned contain a line object, rather than a line
  // number (used to prevent looking up the same line twice).
  TextMarker.prototype.find = function (side, lineObj) {
      var this$1 = this;

if (side == null && this.type == "bookmark") { side = 1; }
    var from, to;
    for (var i = 0; i < this.lines.length; ++i) {
      var line = this$1.lines[i];
      var span = getMarkedSpanFor(line.markedSpans, this$1);
      if (span.from != null) {
        from = Pos(lineObj ? line : lineNo(line), span.from);
        if (side == -1) { return from }
      }
      if (span.to != null) {
        to = Pos(lineObj ? line : lineNo(line), span.to);
        if (side == 1) { return to }
      }
    }
    return from && {from: from, to: to}
  };

// Signals that the marker's widget changed, and surrounding layout
  // should be recomputed.
  TextMarker.prototype.changed = function () {
      var this$1 = this;

TextMarker.prototype.attachLine = function (line) {
    if (!this.lines.length && this.doc.cm) {
      var op = this.doc.cm.curOp;
      if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)
        { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this); }
    }
    this.lines.push(line);
  };

TextMarker.prototype.detachLine = function (line) {
    this.lines.splice(indexOf(this.lines, line), 1);
    if (!this.lines.length && this.doc.cm) {
      var op = this.doc.cm.curOp
      ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this);
    }
  };
  eventMixin(TextMarker);

// Create a marker, wire it up to the right lines, and
  function markText(doc, from, to, options, type) {
    // Shared markers (across linked documents) are handled separately
    // (markTextShared will call out to this again, once per
    // document).
    if (options && options.shared) { return markTextShared(doc, from, to, options, type) }
    // Ensure we are in an operation.
    if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) }

if (marker.addToHistory)
      { addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN); }

if (marker.clearOnEnter) { on(marker, "beforeCursorEnter", function () { return marker.clear(); }); }

if (marker.readOnly) {
      seeReadOnlySpans();
      if (doc.history.done.length || doc.history.undone.length)
        { doc.clearHistory(); }
    }
    if (marker.collapsed) {
      marker.id = ++nextMarkerId;
      marker.atomic = true;
    }
    if (cm) {
      // Sync editor state
      if (updateMaxLine) { cm.curOp.updateMaxLine = true; }
      if (marker.collapsed)
        { regChange(cm, from.line, to.line + 1); }
      else if (marker.className || marker.startStyle || marker.endStyle || marker.css ||
               marker.attributes || marker.title)
        { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, "text"); } }
      if (marker.atomic) { reCheckSelection(cm.doc); }
      signalLater(cm, "markerAdded", cm, marker);
    }
    return marker
  }

// SHARED TEXTMARKERS

// A shared marker spans multiple linked documents. It is
  // implemented as a meta-marker-object controlling multiple normal
  // markers.
  var SharedTextMarker = function(markers, primary) {
    var this$1 = this;

this.markers = markers;
    this.primary = primary;
    for (var i = 0; i < markers.length; ++i)
      { markers[i].parent = this$1; }
  };

SharedTextMarker.prototype.clear = function () {
      var this$1 = this;

if (this.explicitlyCleared) { return }
    this.explicitlyCleared = true;
    for (var i = 0; i < this.markers.length; ++i)
      { this$1.markers[i].clear(); }
    signalLater(this, "clear");
  };

SharedTextMarker.prototype.find = function (side, lineObj) {
    return this.primary.find(side, lineObj)
  };
  eventMixin(SharedTextMarker);

function findSharedMarkers(doc) {
    return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; })
  }

for (var i = 0; i < markers.length; i++) loop( i );
  }

var nextDocId = 0;
  var Doc = function(text, mode, firstLine, lineSep, direction) {
    if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep, direction) }
    if (firstLine == null) { firstLine = 0; }

BranchChunk.call(this, [new LeafChunk([new Line("", null)])]);
    this.first = firstLine;
    this.scrollTop = this.scrollLeft = 0;
    this.cantEdit = false;
    this.cleanGeneration = 1;
    this.modeFrontier = this.highlightFrontier = firstLine;
    var start = Pos(firstLine, 0);
    this.sel = simpleSelection(start);
    this.history = new History(null);
    this.id = ++nextDocId;
    this.modeOption = mode;
    this.lineSep = lineSep;
    this.direction = (direction == "rtl") ? "rtl" : "ltr";
    this.extend = false;

if (typeof text == "string") { text = this.splitLines(text); }
    updateDoc(this, {from: start, to: start, text: text});
    setSelection(this, simpleSelection(start), sel_dontScroll);
  };

Doc.prototype = createObj(BranchChunk.prototype, {
    constructor: Doc,
    // Iterate over the document. Supports two forms -- with only one
    // argument, it calls that for each line in the document. With
    // three, it iterates over the range given by the first two (with
    // the second being non-inclusive).
    iter: function(from, to, op) {
      if (op) { this.iterN(from - this.first, to - from, op); }
      else { this.iterN(this.first, this.first + this.size, from); }
    },

// Non-public interface for adding and removing lines.
    insert: function(at, lines) {
      var height = 0;
      for (var i = 0; i < lines.length; ++i) { height += lines[i].height; }
      this.insertInner(at - this.first, lines, height);
    },
    remove: function(at, n) { this.removeInner(at - this.first, n); },

// From here, the methods are part of the public interface. Most
    // are also available from CodeMirror (editor) instances.

getValue: function(lineSep) {
      var lines = getLines(this, this.first, this.first + this.size);
      if (lineSep === false) { return lines }
      return lines.join(lineSep || this.lineSeparator())
    },
    setValue: docMethodOp(function(code) {
      var top = Pos(this.first, 0), last = this.first + this.size - 1;
      makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),
                        text: this.splitLines(code), origin: "setValue", full: true}, true);
      if (this.cm) { scrollToCoords(this.cm, 0, 0); }
      setSelection(this, simpleSelection(top), sel_dontScroll);
    }),
    replaceRange: function(code, from, to, origin) {
      from = clipPos(this, from);
      to = to ? clipPos(this, to) : from;
      replaceRange(this, code, from, to, origin);
    },
    getRange: function(from, to, lineSep) {
      var lines = getBetween(this, clipPos(this, from), clipPos(this, to));
      if (lineSep === false) { return lines }
      return lines.join(lineSep || this.lineSeparator())
    },

getLine: function(line) {var l = this.getLineHandle(line); return l && l.text},

getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }},
    getLineNumber: function(line) {return lineNo(line)},

getLineHandleVisualStart: function(line) {
      if (typeof line == "number") { line = getLine(this, line); }
      return visualLine(line)
    },

lineCount: function() {return this.size},
    firstLine: function() {return this.first},
    lastLine: function() {return this.first + this.size - 1},

clipPos: function(pos) {return clipPos(this, pos)},

getCursor: function(start) {
      var range$$1 = this.sel.primary(), pos;
      if (start == null || start == "head") { pos = range$$1.head; }
      else if (start == "anchor") { pos = range$$1.anchor; }
      else if (start == "end" || start == "to" || start === false) { pos = range$$1.to(); }
      else { pos = range$$1.from(); }
      return pos
    },
    listSelections: function() { return this.sel.ranges },
    somethingSelected: function() {return this.sel.somethingSelected()},

setCursor: docMethodOp(function(line, ch, options) {
      setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options);
    }),
    setSelection: docMethodOp(function(anchor, head, options) {
      setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options);
    }),
    extendSelection: docMethodOp(function(head, other, options) {
      extendSelection(this, clipPos(this, head), other && clipPos(this, other), options);
    }),
    extendSelections: docMethodOp(function(heads, options) {
      extendSelections(this, clipPosArray(this, heads), options);
    }),
    extendSelectionsBy: docMethodOp(function(f, options) {
      var heads = map(this.sel.ranges, f);
      extendSelections(this, clipPosArray(this, heads), options);
    }),
    setSelections: docMethodOp(function(ranges, primary, options) {
      var this$1 = this;

if (!ranges.length) { return }
      var out = [];
      for (var i = 0; i < ranges.length; i++)
        { out[i] = new Range(clipPos(this$1, ranges[i].anchor),
                           clipPos(this$1, ranges[i].head)); }
      if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex); }
      setSelection(this, normalizeSelection(this.cm, out, primary), options);
    }),
    addSelection: docMethodOp(function(anchor, head, options) {
      var ranges = this.sel.ranges.slice(0);
      ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)));
      setSelection(this, normalizeSelection(this.cm, ranges, ranges.length - 1), options);
    }),

getSelection: function(lineSep) {
      var this$1 = this;

setExtending: function(val) {this.extend = val;},
    getExtending: function() {return this.extend},

historySize: function() {
      var hist = this.history, done = 0, undone = 0;
      for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done; } }
      for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone; } }
      return {undo: done, redo: undone}
    },
    clearHistory: function() {this.history = new History(this.history.maxGeneration);},

markClean: function() {
      this.cleanGeneration = this.changeGeneration(true);
    },
    changeGeneration: function(forceSplit) {
      if (forceSplit)
        { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null; }
      return this.history.generation
    },
    isClean: function (gen) {
      return this.history.generation == (gen || this.cleanGeneration)
    },

getHistory: function() {
      return {done: copyHistoryArray(this.history.done),
              undone: copyHistoryArray(this.history.undone)}
    },
    setHistory: function(histData) {
      var hist = this.history = new History(this.history.maxGeneration);
      hist.done = copyHistoryArray(histData.done.slice(0), null, true);
      hist.undone = copyHistoryArray(histData.undone.slice(0), null, true);
    },

setGutterMarker: docMethodOp(function(line, gutterID, value) {
      return changeLine(this, line, "gutter", function (line) {
        var markers = line.gutterMarkers || (line.gutterMarkers = {});
        markers[gutterID] = value;
        if (!value && isEmpty(markers)) { line.gutterMarkers = null; }
        return true
      })
    }),

clearGutter: docMethodOp(function(gutterID) {
      var this$1 = this;

this.iter(function (line) {
        if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
          changeLine(this$1, line, "gutter", function () {
            line.gutterMarkers[gutterID] = null;
            if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null; }
            return true
          });
        }
      });
    }),

lineInfo: function(line) {
      var n;
      if (typeof line == "number") {
        if (!isLine(this, line)) { return null }
        n = line;
        line = getLine(this, line);
        if (!line) { return null }
      } else {
        n = lineNo(line);
        if (n == null) { return null }
      }
      return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
              textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
              widgets: line.widgets}
    },

addLineClass: docMethodOp(function(handle, where, cls) {
      return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) {
        var prop = where == "text" ? "textClass"
                 : where == "background" ? "bgClass"
                 : where == "gutter" ? "gutterClass" : "wrapClass";
        if (!line[prop]) { line[prop] = cls; }
        else if (classTest(cls).test(line[prop])) { return false }
        else { line[prop] += " " + cls; }
        return true
      })
    }),
    removeLineClass: docMethodOp(function(handle, where, cls) {
      return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) {
        var prop = where == "text" ? "textClass"
                 : where == "background" ? "bgClass"
                 : where == "gutter" ? "gutterClass" : "wrapClass";
        var cur = line[prop];
        if (!cur) { return false }
        else if (cls == null) { line[prop] = null; }
        else {
          var found = cur.match(classTest(cls));
          if (!found) { return false }
          var end = found.index + found[0].length;
          line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null;
        }
        return true
      })
    }),

addLineWidget: docMethodOp(function(handle, node, options) {
      return addLineWidget(this, handle, node, options)
    }),
    removeLineWidget: function(widget) { widget.clear(); },

markText: function(from, to, options) {
      return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range")
    },
    setBookmark: function(pos, options) {
      var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),
                      insertLeft: options && options.insertLeft,
                      clearWhenEmpty: false, shared: options && options.shared,
                      handleMouseEvents: options && options.handleMouseEvents};
      pos = clipPos(this, pos);
      return markText(this, pos, pos, realOpts, "bookmark")
    },
    findMarksAt: function(pos) {
      pos = clipPos(this, pos);
      var markers = [], spans = getLine(this, pos.line).markedSpans;
      if (spans) { for (var i = 0; i < spans.length; ++i) {
        var span = spans[i];
        if ((span.from == null || span.from <= pos.ch) &&
            (span.to == null || span.to >= pos.ch))
          { markers.push(span.marker.parent || span.marker); }
      } }
      return markers
    },
    findMarks: function(from, to, filter) {
      from = clipPos(this, from); to = clipPos(this, to);
      var found = [], lineNo$$1 = from.line;
      this.iter(from.line, to.line + 1, function (line) {
        var spans = line.markedSpans;
        if (spans) { for (var i = 0; i < spans.length; i++) {
          var span = spans[i];
          if (!(span.to != null && lineNo$$1 == from.line && from.ch >= span.to ||
                span.from == null && lineNo$$1 != from.line ||
                span.from != null && lineNo$$1 == to.line && span.from >= to.ch) &&
              (!filter || filter(span.marker)))
            { found.push(span.marker.parent || span.marker); }
        } }
        ++lineNo$$1;
      });
      return found
    },
    getAllMarks: function() {
      var markers = [];
      this.iter(function (line) {
        var sps = line.markedSpans;
        if (sps) { for (var i = 0; i < sps.length; ++i)
          { if (sps[i].from != null) { markers.push(sps[i].marker); } } }
      });
      return markers
    },

posFromIndex: function(off) {
      var ch, lineNo$$1 = this.first, sepSize = this.lineSeparator().length;
      this.iter(function (line) {
        var sz = line.text.length + sepSize;
        if (sz > off) { ch = off; return true }
        off -= sz;
        ++lineNo$$1;
      });
      return clipPos(this, Pos(lineNo$$1, ch))
    },
    indexFromPos: function (coords) {
      coords = clipPos(this, coords);
      var index = coords.ch;
      if (coords.line < this.first || coords.ch < 0) { return 0 }
      var sepSize = this.lineSeparator().length;
      this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value
        index += line.text.length + sepSize;
      });
      return index
    },

copy: function(copyHistory) {
      var doc = new Doc(getLines(this, this.first, this.first + this.size),
                        this.modeOption, this.first, this.lineSep, this.direction);
      doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft;
      doc.sel = this.sel;
      doc.extend = false;
      if (copyHistory) {
        doc.history.undoDepth = this.history.undoDepth;
        doc.setHistory(this.getHistory());
      }
      return doc
    },

linkedDoc: function(options) {
      if (!options) { options = {}; }
      var from = this.first, to = this.first + this.size;
      if (options.from != null && options.from > from) { from = options.from; }
      if (options.to != null && options.to < to) { to = options.to; }
      var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep, this.direction);
      if (options.sharedHist) { copy.history = this.history
      ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist});
      copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}];
      copySharedMarkers(copy, findSharedMarkers(this));
      return copy
    },
    unlinkDoc: function(other) {
      var this$1 = this;

if (other instanceof CodeMirror) { other = other.doc; }
      if (this.linked) { for (var i = 0; i < this.linked.length; ++i) {
        var link = this$1.linked[i];
        if (link.doc != other) { continue }
        this$1.linked.splice(i, 1);
        other.unlinkDoc(this$1);
        detachSharedMarkers(findSharedMarkers(this$1));
        break
      } }
      // If the histories were shared, split them again
      if (other.history == this.history) {
        var splitIds = [other.id];
        linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true);
        other.history = new History(null);
        other.history.done = copyHistoryArray(this.history.done, splitIds);
        other.history.undone = copyHistoryArray(this.history.undone, splitIds);
      }
    },
    iterLinkedDocs: function(f) {linkedDocs(this, f);},

getMode: function() {return this.mode},
    getEditor: function() {return this.cm},

splitLines: function(str) {
      if (this.lineSep) { return str.split(this.lineSep) }
      return splitLinesAuto(str)
    },
    lineSeparator: function() { return this.lineSep || "\n" },

setDirection: docMethodOp(function (dir) {
      if (dir != "rtl") { dir = "ltr"; }
      if (dir == this.direction) { return }
      this.direction = dir;
      this.iter(function (line) { return line.order = null; });
      if (this.cm) { directionChanged(this.cm); }
    })
  });

// Public alias.
  Doc.prototype.eachLine = Doc.prototype.iter;

// Kludge to work around strange IE behavior where it'll sometimes
  // re-fire a series of drag-related events right after the drop (#1551)
  var lastDrop = 0;

function onDragStart(cm, e) {
    if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }
    if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return }

e.dataTransfer.setData("Text", cm.getSelection());
    e.dataTransfer.effectAllowed = "copyMove";

// Use dummy image instead of default browsers image.
    // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
    if (e.dataTransfer.setDragImage && !safari) {
      var img = elt("img", null, null, "position: fixed; left: 0; top: 0;");
      img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
      if (presto) {
        img.width = img.height = 1;
        cm.display.wrapper.appendChild(img);
        // Force a relayout, or Opera won't use our image for some obscure reason
        img._top = img.offsetTop;
      }
      e.dataTransfer.setDragImage(img, 0, 0);
      if (presto) { img.parentNode.removeChild(img); }
    }
  }

function clearDragCursor(cm) {
    if (cm.display.dragCursor) {
      cm.display.lineSpace.removeChild(cm.display.dragCursor);
      cm.display.dragCursor = null;
    }
  }

// These must be handled carefully, because naively registering a
  // handler for each editor will cause the editors to never be
  // garbage collected.

var keyNames = {
    3: "Pause", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
    19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
    36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
    46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod",
    106: "*", 107: "=", 109: "-", 110: ".", 111: "/", 127: "Delete", 145: "ScrollLock",
    173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\",
    221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete",
    63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert"
  };

// Number keys
  for (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i); }
  // Alphabetic keys
  for (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1); }
  // Function keys
  for (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = "F" + i$2; }

var keyMap = {};

keyMap.basic = {
    "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
    "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
    "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore",
    "Tab": "defaultTab", "Shift-Tab": "indentAuto",
    "Enter": "newlineAndIndent", "Insert": "toggleOverwrite",
    "Esc": "singleSelection"
  };
  // Note that the save and find-related commands aren't defined by
  // default. User code or addons can define them. Unknown commands
  // are simply ignored.
  keyMap.pcDefault = {
    "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
    "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown",
    "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
    "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
    "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
    "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
    "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection",
    "fallthrough": "basic"
  };
  // Very basic readline/emacs-style bindings, which are standard on Mac.
  keyMap.emacsy = {
    "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
    "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
    "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
    "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars",
    "Ctrl-O": "openLine"
  };
  keyMap.macDefault = {
    "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
    "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
    "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore",
    "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
    "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
    "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight",
    "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd",
    "fallthrough": ["basic", "emacsy"]
  };
  keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault;

// KEYMAP DISPATCH

// This is a kludge to keep keymaps mostly working as raw objects
  // (backwards compatibility) while at the same time support features
  // like normalization and multi-stroke key bindings. It compiles a
  // new normalized keymap, and then updates the old object to reflect
  // this.
  function normalizeKeyMap(keymap) {
    var copy = {};
    for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) {
      var value = keymap[keyname];
      if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue }
      if (value == "...") { delete keymap[keyname]; continue }

function lookupKey(key, map$$1, handle, context) {
    map$$1 = getKeyMap(map$$1);
    var found = map$$1.call ? map$$1.call(key, context) : map$$1[key];
    if (found === false) { return "nothing" }
    if (found === "...") { return "multi" }
    if (found != null && handle(found)) { return "handled" }

if (map$$1.fallthrough) {
      if (Object.prototype.toString.call(map$$1.fallthrough) != "[object Array]")
        { return lookupKey(key, map$$1.fallthrough, handle, context) }
      for (var i = 0; i < map$$1.fallthrough.length; i++) {
        var result = lookupKey(key, map$$1.fallthrough[i], handle, context);
        if (result) { return result }
      }
    }
  }

// Modifier key presses don't count as 'real' key presses for the
  // purpose of keymap fallthrough.
  function isModifierKey(value) {
    var name = typeof value == "string" ? value : keyNames[value.keyCode];
    return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod"
  }

// Look up the name of a key as indicated by an event object.
  function keyName(event, noShift) {
    if (presto && event.keyCode == 34 && event["char"]) { return false }
    var name = keyNames[event.keyCode];
    if (name == null || event.altGraphKey) { return false }
    // Ctrl-ScrollLock has keyCode 3, same as Ctrl-Pause,
    // so we'll use event.code when available (Chrome 48+, FF 38+, Safari 10.1+)
    if (event.keyCode == 3 && event.code) { name = event.code; }
    return addModifierNames(name, event, noShift)
  }

function getKeyMap(val) {
    return typeof val == "string" ? keyMap[val] : val
  }

// Helper for deleting text near the selection(s), used to implement
  // backspace, delete, and similar functionality.
  function deleteNearSelection(cm, compute) {
    var ranges = cm.doc.sel.ranges, kill = [];
    // Build up a set of ranges to kill first, merging overlapping
    // ranges.
    for (var i = 0; i < ranges.length; i++) {
      var toKill = compute(ranges[i]);
      while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
        var replaced = kill.pop();
        if (cmp(replaced.from, toKill.from) < 0) {
          toKill.from = replaced.from;
          break
        }
      }
      kill.push(toKill);
    }
    // Next, remove those actual ranges.
    runInOp(cm, function () {
      for (var i = kill.length - 1; i >= 0; i--)
        { replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete"); }
      ensureCursorVisible(cm);
    });
  }

function moveCharLogically(line, ch, dir) {
    var target = skipExtendingChars(line.text, ch + dir, dir);
    return target < 0 || target > line.text.length ? null : target
  }

function moveLogically(line, start, dir) {
    var ch = moveCharLogically(line, start.ch, dir);
    return ch == null ? null : new Pos(start.line, ch, dir < 0 ? "after" : "before")
  }

if (cm.doc.direction == "rtl" || part.level == 1) {
      var moveInStorageOrder = (part.level == 1) == (dir < 0);
      var ch = mv(start, moveInStorageOrder ? 1 : -1);
      if (ch != null && (!moveInStorageOrder ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) {
        // Case 2: We move within an rtl part or in an rtl editor on the same visual line
        var sticky = moveInStorageOrder ? "before" : "after";
        return new Pos(start.line, ch, sticky)
      }
    }

// Case 3: Could not move within this bidi part in this visual line, so leave
    // the current bidi part

var searchInVisualLine = function (partPos, dir, wrappedLineExtent) {
      var getRes = function (ch, moveInStorageOrder) { return moveInStorageOrder
        ? new Pos(start.line, mv(ch, 1), "before")
        : new Pos(start.line, ch, "after"); };

for (; partPos >= 0 && partPos < bidi.length; partPos += dir) {
        var part = bidi[partPos];
        var moveInStorageOrder = (dir > 0) == (part.level != 1);
        var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1);
        if (part.from <= ch && ch < part.to) { return getRes(ch, moveInStorageOrder) }
        ch = moveInStorageOrder ? part.from : mv(part.to, -1);
        if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) { return getRes(ch, moveInStorageOrder) }
      }
    };

// Case 3a: Look for other bidi parts on the same visual line
    var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent);
    if (res) { return res }

// Case 3b: Look for other bidi parts on the next visual line
    var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1);
    if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {
      res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh));
      if (res) { return res }
    }

// Case 4: Nowhere to move
    return null
  }

// Commands are parameter-less actions that can be performed on an
  // editor, mostly used for keybindings.
  var commands = {
    selectAll: selectAll,
    singleSelection: function (cm) { return cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll); },
    killLine: function (cm) { return deleteNearSelection(cm, function (range) {
      if (range.empty()) {
        var len = getLine(cm.doc, range.head.line).text.length;
        if (range.head.ch == len && range.head.line < cm.lastLine())
          { return {from: range.head, to: Pos(range.head.line + 1, 0)} }
        else
          { return {from: range.head, to: Pos(range.head.line, len)} }
      } else {
        return {from: range.from(), to: range.to()}
      }
    }); },
    deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({
      from: Pos(range.from().line, 0),
      to: clipPos(cm.doc, Pos(range.to().line + 1, 0))
    }); }); },
    delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({
      from: Pos(range.from().line, 0), to: range.from()
    }); }); },
    delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) {
      var top = cm.charCoords(range.head, "div").top + 5;
      var leftPos = cm.coordsChar({left: 0, top: top}, "div");
      return {from: leftPos, to: range.from()}
    }); },
    delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) {
      var top = cm.charCoords(range.head, "div").top + 5;
      var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div");
      return {from: range.from(), to: rightPos }
    }); },
    undo: function (cm) { return cm.undo(); },
    redo: function (cm) { return cm.redo(); },
    undoSelection: function (cm) { return cm.undoSelection(); },
    redoSelection: function (cm) { return cm.redoSelection(); },
    goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); },
    goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); },
    goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); },
      {origin: "+move", bias: 1}
    ); },
    goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); },
      {origin: "+move", bias: 1}
    ); },
    goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); },
      {origin: "+move", bias: -1}
    ); },
    goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) {
      var top = cm.cursorCoords(range.head, "div").top + 5;
      return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
    }, sel_move); },
    goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) {
      var top = cm.cursorCoords(range.head, "div").top + 5;
      return cm.coordsChar({left: 0, top: top}, "div")
    }, sel_move); },
    goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) {
      var top = cm.cursorCoords(range.head, "div").top + 5;
      var pos = cm.coordsChar({left: 0, top: top}, "div");
      if (pos.ch < cm.getLine(pos.line).search(/\S/)) { return lineStartSmart(cm, range.head) }
      return pos
    }, sel_move); },
    goLineUp: function (cm) { return cm.moveV(-1, "line"); },
    goLineDown: function (cm) { return cm.moveV(1, "line"); },
    goPageUp: function (cm) { return cm.moveV(-1, "page"); },
    goPageDown: function (cm) { return cm.moveV(1, "page"); },
    goCharLeft: function (cm) { return cm.moveH(-1, "char"); },
    goCharRight: function (cm) { return cm.moveH(1, "char"); },
    goColumnLeft: function (cm) { return cm.moveH(-1, "column"); },
    goColumnRight: function (cm) { return cm.moveH(1, "column"); },
    goWordLeft: function (cm) { return cm.moveH(-1, "word"); },
    goGroupRight: function (cm) { return cm.moveH(1, "group"); },
    goGroupLeft: function (cm) { return cm.moveH(-1, "group"); },
    goWordRight: function (cm) { return cm.moveH(1, "word"); },
    delCharBefore: function (cm) { return cm.deleteH(-1, "char"); },
    delCharAfter: function (cm) { return cm.deleteH(1, "char"); },
    delWordBefore: function (cm) { return cm.deleteH(-1, "word"); },
    delWordAfter: function (cm) { return cm.deleteH(1, "word"); },
    delGroupBefore: function (cm) { return cm.deleteH(-1, "group"); },
    delGroupAfter: function (cm) { return cm.deleteH(1, "group"); },
    indentAuto: function (cm) { return cm.indentSelection("smart"); },
    indentMore: function (cm) { return cm.indentSelection("add"); },
    indentLess: function (cm) { return cm.indentSelection("subtract"); },
    insertTab: function (cm) { return cm.replaceSelection("\t"); },
    insertSoftTab: function (cm) {
      var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize;
      for (var i = 0; i < ranges.length; i++) {
        var pos = ranges[i].from();
        var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize);
        spaces.push(spaceStr(tabSize - col % tabSize));
      }
      cm.replaceSelections(spaces);
    },
    defaultTab: function (cm) {
      if (cm.somethingSelected()) { cm.indentSelection("add"); }
      else { cm.execCommand("insertTab"); }
    },
    // Swap the two chars left and right of each selection's head.
    // Move cursor behind the two swapped characters afterwards.
    //
    // Doesn't consider line feeds a character.
    // Doesn't scan more than one line above to find a character.
    // Doesn't do anything on an empty line.
    // Doesn't do anything with non-empty selections.
    transposeChars: function (cm) { return runInOp(cm, function () {
      var ranges = cm.listSelections(), newSel = [];
      for (var i = 0; i < ranges.length; i++) {
        if (!ranges[i].empty()) { continue }
        var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text;
        if (line) {
          if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1); }
          if (cur.ch > 0) {
            cur = new Pos(cur.line, cur.ch + 1);
            cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
                            Pos(cur.line, cur.ch - 2), cur, "+transpose");
          } else if (cur.line > cm.doc.first) {
            var prev = getLine(cm.doc, cur.line - 1).text;
            if (prev) {
              cur = new Pos(cur.line, 1);
              cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +
                              prev.charAt(prev.length - 1),
                              Pos(cur.line - 1, prev.length - 1), cur, "+transpose");
            }
          }
        }
        newSel.push(new Range(cur, cur));
      }
      cm.setSelections(newSel);
    }); },
    newlineAndIndent: function (cm) { return runInOp(cm, function () {
      var sels = cm.listSelections();
      for (var i = sels.length - 1; i >= 0; i--)
        { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input"); }
      sels = cm.listSelections();
      for (var i$1 = 0; i$1 < sels.length; i$1++)
        { cm.indentLine(sels[i$1].from().line, null, true); }
      ensureCursorVisible(cm);
    }); },
    openLine: function (cm) { return cm.replaceSelection("\n", "start"); },
    toggleOverwrite: function (cm) { return cm.toggleOverwrite(); }
  };

// Run a handler that was bound to a key.
  function doHandleBinding(cm, bound, dropShift) {
    if (typeof bound == "string") {
      bound = commands[bound];
      if (!bound) { return false }
    }
    // Ensure previous input has been read, so that the handler sees a
    // consistent view of the document
    cm.display.input.ensurePolled();
    var prevShift = cm.display.shift, done = false;
    try {
      if (cm.isReadOnly()) { cm.state.suppressEdits = true; }
      if (dropShift) { cm.display.shift = false; }
      done = bound(cm) != Pass;
    } finally {
      cm.display.shift = prevShift;
      cm.state.suppressEdits = false;
    }
    return done
  }

// Note that, despite the name, this function is also used to check
  // for bound mouse clicks.

var stopSeq = new Delayed;

function dispatchKeyInner(cm, name, e, handle) {
    var result = lookupKeyForEditor(cm, name, handle);

if (result == "multi")
      { cm.state.keySeq = name; }
    if (result == "handled")
      { signalLater(cm, "keyHandled", cm, name, e); }

if (result == "handled" || result == "multi") {
      e_preventDefault(e);
      restartBlink(cm);
    }

return !!result
  }

// Handle a key from the keydown event.
  function handleKeyBinding(cm, e) {
    var name = keyName(e, true);
    if (!name) { return false }

if (e.shiftKey && !cm.state.keySeq) {
      // First try to resolve full name (including 'Shift-'). Failing
      // that, see if there is a cursor-motion command (starting with
      // 'go') bound to the keyname without 'Shift-'.
      return dispatchKey(cm, "Shift-" + name, e, function (b) { return doHandleBinding(cm, b, true); })
          || dispatchKey(cm, name, e, function (b) {
               if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion)
                 { return doHandleBinding(cm, b) }
             })
    } else {
      return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); })
    }
  }

// Handle a key from the keypress event
  function handleCharBinding(cm, e, ch) {
    return dispatchKey(cm, "'" + ch + "'", e, function (b) { return doHandleBinding(cm, b, true); })
  }

// Turn mouse into crosshair when Alt is held on Mac.
    if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className))
      { showCrossHair(cm); }
  }

function showCrossHair(cm) {
    var lineDiv = cm.display.lineDiv;
    addClass(lineDiv, "CodeMirror-crosshair");

function up(e) {
      if (e.keyCode == 18 || !e.altKey) {
        rmClass(lineDiv, "CodeMirror-crosshair");
        off(document, "keyup", up);
        off(document, "mouseover", up);
      }
    }
    on(document, "keyup", up);
    on(document, "mouseover", up);
  }

function onKeyUp(e) {
    if (e.keyCode == 16) { this.doc.sel.shift = false; }
    signalDOMEvent(this, e);
  }

var DOUBLECLICK_DELAY = 400;

var PastClick = function(time, pos, button) {
    this.time = time;
    this.pos = pos;
    this.button = button;
  };

PastClick.prototype.compare = function (time, pos, button) {
    return this.time + DOUBLECLICK_DELAY > time &&
      cmp(pos, this.pos) == 0 && button == this.button
  };

var lastClick, lastDoubleClick;
  function clickRepeat(pos, button) {
    var now = +new Date;
    if (lastDoubleClick && lastDoubleClick.compare(now, pos, button)) {
      lastClick = lastDoubleClick = null;
      return "triple"
    } else if (lastClick && lastClick.compare(now, pos, button)) {
      lastDoubleClick = new PastClick(now, pos, button);
      lastClick = null;
      return "double"
    } else {
      lastClick = new PastClick(now, pos, button);
      lastDoubleClick = null;
      return "single"
    }
  }

// A mouse down can be a single click, double click, triple click,
  // start of selection drag, start of text drag, new cursor
  // (ctrl-click), rectangle drag (alt-drag), or xwin
  // middle-click-paste. Or it might be a click on something we should
  // not interfere with, such as a scrollbar or widget.
  function onMouseDown(e) {
    var cm = this, display = cm.display;
    if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return }
    display.input.ensurePolled();
    display.shift = e.shiftKey;

if (eventInWidget(display, e)) {
      if (!webkit) {
        // Briefly turn off draggability, to allow widgets to do
        // normal dragging things.
        display.scroller.draggable = false;
        setTimeout(function () { return display.scroller.draggable = true; }, 100);
      }
      return
    }
    if (clickInGutter(cm, e)) { return }
    var pos = posFromMouse(cm, e), button = e_button(e), repeat = pos ? clickRepeat(pos, button) : "single";
    window.focus();

// #3261: make sure, that we're not starting a second selection
    if (button == 1 && cm.state.selectingText)
      { cm.state.selectingText(e); }

if (pos && handleMappedButton(cm, button, pos, repeat, e)) { return }

if (button == 1) {
      if (pos) { leftButtonDown(cm, pos, repeat, e); }
      else if (e_target(e) == display.scroller) { e_preventDefault(e); }
    } else if (button == 2) {
      if (pos) { extendSelection(cm.doc, pos); }
      setTimeout(function () { return display.input.focus(); }, 20);
    } else if (button == 3) {
      if (captureRightClick) { cm.display.input.onContextMenu(e); }
      else { delayBlurEvent(cm); }
    }
  }

function handleMappedButton(cm, button, pos, repeat, event) {
    var name = "Click";
    if (repeat == "double") { name = "Double" + name; }
    else if (repeat == "triple") { name = "Triple" + name; }
    name = (button == 1 ? "Left" : button == 2 ? "Middle" : "Right") + name;

return dispatchKey(cm,  addModifierNames(name, event), event, function (bound) {
      if (typeof bound == "string") { bound = commands[bound]; }
      if (!bound) { return false }
      var done = false;
      try {
        if (cm.isReadOnly()) { cm.state.suppressEdits = true; }
        done = bound(cm, pos) != Pass;
      } finally {
        cm.state.suppressEdits = false;
      }
      return done
    })
  }

function leftButtonDown(cm, pos, repeat, event) {
    if (ie) { setTimeout(bind(ensureFocus, cm), 0); }
    else { cm.curOp.focus = activeElt(); }

var behavior = configureMouse(cm, repeat, event);

var sel = cm.doc.sel, contained;
    if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&
        repeat == "single" && (contained = sel.contains(pos)) > -1 &&
        (cmp((contained = sel.ranges[contained]).from(), pos) < 0 || pos.xRel > 0) &&
        (cmp(contained.to(), pos) > 0 || pos.xRel < 0))
      { leftButtonStartDrag(cm, event, pos, behavior); }
    else
      { leftButtonSelect(cm, event, pos, behavior); }
  }

// Start a text drag. When it ends, see if any dragging actually
  // happen, and treat as a click if it didn't.
  function leftButtonStartDrag(cm, event, pos, behavior) {
    var display = cm.display, moved = false;
    var dragEnd = operation(cm, function (e) {
      if (webkit) { display.scroller.draggable = false; }
      cm.state.draggingText = false;
      off(display.wrapper.ownerDocument, "mouseup", dragEnd);
      off(display.wrapper.ownerDocument, "mousemove", mouseMove);
      off(display.scroller, "dragstart", dragStart);
      off(display.scroller, "drop", dragEnd);
      if (!moved) {
        e_preventDefault(e);
        if (!behavior.addNew)
          { extendSelection(cm.doc, pos, null, null, behavior.extend); }
        // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
        if (webkit || ie && ie_version == 9)
          { setTimeout(function () {display.wrapper.ownerDocument.body.focus(); display.input.focus();}, 20); }
        else
          { display.input.focus(); }
      }
    });
    var mouseMove = function(e2) {
      moved = moved || Math.abs(event.clientX - e2.clientX) + Math.abs(event.clientY - e2.clientY) >= 10;
    };
    var dragStart = function () { return moved = true; };
    // Let the drag handler handle this.
    if (webkit) { display.scroller.draggable = true; }
    cm.state.draggingText = dragEnd;
    dragEnd.copy = !behavior.moveOnDrag;
    // IE's approach to draggable
    if (display.scroller.dragDrop) { display.scroller.dragDrop(); }
    on(display.wrapper.ownerDocument, "mouseup", dragEnd);
    on(display.wrapper.ownerDocument, "mousemove", mouseMove);
    on(display.scroller, "dragstart", dragStart);
    on(display.scroller, "drop", dragEnd);

delayBlurEvent(cm);
    setTimeout(function () { return display.input.focus(); }, 20);
  }

function rangeForUnit(cm, pos, unit) {
    if (unit == "char") { return new Range(pos, pos) }
    if (unit == "word") { return cm.findWordAt(pos) }
    if (unit == "line") { return new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) }
    var result = unit(cm, pos);
    return new Range(result.from, result.to)
  }

// Normal selection, as opposed to text dragging.
  function leftButtonSelect(cm, event, start, behavior) {
    var display = cm.display, doc = cm.doc;
    e_preventDefault(event);

var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges;
    if (behavior.addNew && !behavior.extend) {
      ourIndex = doc.sel.contains(start);
      if (ourIndex > -1)
        { ourRange = ranges[ourIndex]; }
      else
        { ourRange = new Range(start, start); }
    } else {
      ourRange = doc.sel.primary();
      ourIndex = doc.sel.primIndex;
    }

if (behavior.unit == "rectangle") {
      if (!behavior.addNew) { ourRange = new Range(start, start); }
      start = posFromMouse(cm, event, true, true);
      ourIndex = -1;
    } else {
      var range$$1 = rangeForUnit(cm, start, behavior.unit);
      if (behavior.extend)
        { ourRange = extendRange(ourRange, range$$1.anchor, range$$1.head, behavior.extend); }
      else
        { ourRange = range$$1; }
    }

if (!behavior.addNew) {
      ourIndex = 0;
      setSelection(doc, new Selection([ourRange], 0), sel_mouse);
      startSel = doc.sel;
    } else if (ourIndex == -1) {
      ourIndex = ranges.length;
      setSelection(doc, normalizeSelection(cm, ranges.concat([ourRange]), ourIndex),
                   {scroll: false, origin: "*mouse"});
    } else if (ranges.length > 1 && ranges[ourIndex].empty() && behavior.unit == "char" && !behavior.extend) {
      setSelection(doc, normalizeSelection(cm, ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),
                   {scroll: false, origin: "*mouse"});
      startSel = doc.sel;
    } else {
      replaceOneSelection(doc, ourIndex, ourRange, sel_mouse);
    }

var lastPos = start;
    function extendTo(pos) {
      if (cmp(lastPos, pos) == 0) { return }
      lastPos = pos;

if (behavior.unit == "rectangle") {
        var ranges = [], tabSize = cm.options.tabSize;
        var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize);
        var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize);
        var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol);
        for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));
             line <= end; line++) {
          var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize);
          if (left == right)
            { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))); }
          else if (text.length > leftPos)
            { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))); }
        }
        if (!ranges.length) { ranges.push(new Range(start, start)); }
        setSelection(doc, normalizeSelection(cm, startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),
                     {origin: "*mouse", scroll: false});
        cm.scrollIntoView(pos);
      } else {
        var oldRange = ourRange;
        var range$$1 = rangeForUnit(cm, pos, behavior.unit);
        var anchor = oldRange.anchor, head;
        if (cmp(range$$1.anchor, anchor) > 0) {
          head = range$$1.head;
          anchor = minPos(oldRange.from(), range$$1.anchor);
        } else {
          head = range$$1.anchor;
          anchor = maxPos(oldRange.to(), range$$1.head);
        }
        var ranges$1 = startSel.ranges.slice(0);
        ranges$1[ourIndex] = bidiSimplify(cm, new Range(clipPos(doc, anchor), head));
        setSelection(doc, normalizeSelection(cm, ranges$1, ourIndex), sel_mouse);
      }
    }

var editorSize = display.wrapper.getBoundingClientRect();
    // Used to ensure timeout re-tries don't fire when another extend
    // happened in the meantime (clearTimeout isn't reliable -- at
    // least on Chrome, the timeouts still happen even when cleared,
    // if the clear happens after their scheduled firing time).
    var counter = 0;

function done(e) {
      cm.state.selectingText = false;
      counter = Infinity;
      e_preventDefault(e);
      display.input.focus();
      off(display.wrapper.ownerDocument, "mousemove", move);
      off(display.wrapper.ownerDocument, "mouseup", up);
      doc.history.lastSelOrigin = null;
    }

// Used when mouse-selecting to adjust the anchor to the proper side
  // of a bidi jump depending on the visual position of the head.
  function bidiSimplify(cm, range$$1) {
    var anchor = range$$1.anchor;
    var head = range$$1.head;
    var anchorLine = getLine(cm.doc, anchor.line);
    if (cmp(anchor, head) == 0 && anchor.sticky == head.sticky) { return range$$1 }
    var order = getOrder(anchorLine);
    if (!order) { return range$$1 }
    var index = getBidiPartAt(order, anchor.ch, anchor.sticky), part = order[index];
    if (part.from != anchor.ch && part.to != anchor.ch) { return range$$1 }
    var boundary = index + ((part.from == anchor.ch) == (part.level != 1) ? 0 : 1);
    if (boundary == 0 || boundary == order.length) { return range$$1 }

// Compute the relative visual position of the head compared to the
    // anchor (<0 is to the left, >0 to the right)
    var leftSide;
    if (head.line != anchor.line) {
      leftSide = (head.line - anchor.line) * (cm.doc.direction == "ltr" ? 1 : -1) > 0;
    } else {
      var headIndex = getBidiPartAt(order, head.ch, head.sticky);
      var dir = headIndex - index || (head.ch - anchor.ch) * (part.level == 1 ? -1 : 1);
      if (headIndex == boundary - 1 || headIndex == boundary)
        { leftSide = dir < 0; }
      else
        { leftSide = dir > 0; }
    }

var usePart = order[boundary + (leftSide ? -1 : 0)];
    var from = leftSide == (usePart.level == 1);
    var ch = from ? usePart.from : usePart.to, sticky = from ? "after" : "before";
    return anchor.ch == ch && anchor.sticky == sticky ? range$$1 : new Range(new Pos(anchor.line, ch, sticky), head)
  }

// Determines whether an event happened in the gutter, and fires the
  // handlers for the corresponding event.
  function gutterEvent(cm, e, type, prevent) {
    var mX, mY;
    if (e.touches) {
      mX = e.touches[0].clientX;
      mY = e.touches[0].clientY;
    } else {
      try { mX = e.clientX; mY = e.clientY; }
      catch(e) { return false }
    }
    if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false }
    if (prevent) { e_preventDefault(e); }

var display = cm.display;
    var lineBox = display.lineDiv.getBoundingClientRect();

if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) }
    mY -= lineBox.top - display.viewOffset;

for (var i = 0; i < cm.options.gutters.length; ++i) {
      var g = display.gutters.childNodes[i];
      if (g && g.getBoundingClientRect().right >= mX) {
        var line = lineAtHeight(cm.doc, mY);
        var gutter = cm.options.gutters[i];
        signal(cm, type, cm, line, gutter, e);
        return e_defaultPrevented(e)
      }
    }
  }

function clickInGutter(cm, e) {
    return gutterEvent(cm, e, "gutterClick", true)
  }

// CONTEXT MENU HANDLING

// To make the context menu work, we need to briefly unhide the
  // textarea (making it as unobtrusive as possible) to let the
  // right-click take effect on it.
  function onContextMenu(cm, e) {
    if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return }
    if (signalDOMEvent(cm, e, "contextmenu")) { return }
    if (!captureRightClick) { cm.display.input.onContextMenu(e); }
  }

function contextMenuInGutter(cm, e) {
    if (!hasHandler(cm, "gutterContextMenu")) { return false }
    return gutterEvent(cm, e, "gutterContextMenu", false)
  }

function themeChanged(cm) {
    cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
      cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");
    clearCaches(cm);
  }

var Init = {toString: function(){return "CodeMirror.Init"}};

var defaults = {};
  var optionHandlers = {};

function defineOptions(CodeMirror) {
    var optionHandlers = CodeMirror.optionHandlers;

CodeMirror.defineOption = option;

// Passed to option handlers when there is no old value.
    CodeMirror.Init = Init;

// These two are, on init, called from the constructor because they
    // have to be initialized before the editor can start at all.
    option("value", "", function (cm, val) { return cm.setValue(val); }, true);
    option("mode", null, function (cm, val) {
      cm.doc.modeOption = val;
      loadMode(cm);
    }, true);

option("indentUnit", 2, loadMode, true);
    option("indentWithTabs", false);
    option("smartIndent", true);
    option("tabSize", 4, function (cm) {
      resetModeState(cm);
      clearCaches(cm);
      regChange(cm);
    }, true);

option("lineSeparator", null, function (cm, val) {
      cm.doc.lineSep = val;
      if (!val) { return }
      var newBreaks = [], lineNo = cm.doc.first;
      cm.doc.iter(function (line) {
        for (var pos = 0;;) {
          var found = line.text.indexOf(val, pos);
          if (found == -1) { break }
          pos = found + val.length;
          newBreaks.push(Pos(lineNo, found));
        }
        lineNo++;
      });
      for (var i = newBreaks.length - 1; i >= 0; i--)
        { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)); }
    });
    option("specialChars", /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b-\u200f\u2028\u2029\ufeff]/g, function (cm, val, old) {
      cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g");
      if (old != Init) { cm.refresh(); }
    });
    option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true);
    option("electricChars", true);
    option("inputStyle", mobile ? "contenteditable" : "textarea", function () {
      throw new Error("inputStyle can not (yet) be changed in a running editor") // FIXME
    }, true);
    option("spellcheck", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true);
    option("autocorrect", false, function (cm, val) { return cm.getInputField().autocorrect = val; }, true);
    option("autocapitalize", false, function (cm, val) { return cm.getInputField().autocapitalize = val; }, true);
    option("rtlMoveVisually", !windows);
    option("wholeLineUpdateBefore", true);

option("theme", "default", function (cm) {
      themeChanged(cm);
      guttersChanged(cm);
    }, true);
    option("keyMap", "default", function (cm, val, old) {
      var next = getKeyMap(val);
      var prev = old != Init && getKeyMap(old);
      if (prev && prev.detach) { prev.detach(cm, next); }
      if (next.attach) { next.attach(cm, prev || null); }
    });
    option("extraKeys", null);
    option("configureMouse", null);

option("lineWrapping", false, wrappingChanged, true);
    option("gutters", [], function (cm) {
      setGuttersForLineNumbers(cm.options);
      guttersChanged(cm);
    }, true);
    option("fixedGutter", true, function (cm, val) {
      cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0";
      cm.refresh();
    }, true);
    option("coverGutterNextToScrollbar", false, function (cm) { return updateScrollbars(cm); }, true);
    option("scrollbarStyle", "native", function (cm) {
      initScrollbars(cm);
      updateScrollbars(cm);
      cm.display.scrollbars.setScrollTop(cm.doc.scrollTop);
      cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft);
    }, true);
    option("lineNumbers", false, function (cm) {
      setGuttersForLineNumbers(cm.options);
      guttersChanged(cm);
    }, true);
    option("firstLineNumber", 1, guttersChanged, true);
    option("lineNumberFormatter", function (integer) { return integer; }, guttersChanged, true);
    option("showCursorWhenSelecting", false, updateSelection, true);

option("resetSelectionOnContextMenu", true);
    option("lineWiseCopyCut", true);
    option("pasteLinesPerSelection", true);
    option("selectionsMayTouch", false);

option("readOnly", false, function (cm, val) {
      if (val == "nocursor") {
        onBlur(cm);
        cm.display.input.blur();
      }
      cm.display.input.readOnlyChanged(val);
    });
    option("disableInput", false, function (cm, val) {if (!val) { cm.display.input.reset(); }}, true);
    option("dragDrop", true, dragDropChanged);
    option("allowDropFileTypes", null);

option("cursorBlinkRate", 530);
    option("cursorScrollMargin", 0);
    option("cursorHeight", 1, updateSelection, true);
    option("singleCursorHeightPerLine", true, updateSelection, true);
    option("workTime", 100);
    option("workDelay", 100);
    option("flattenSpans", true, resetModeState, true);
    option("addModeClass", false, resetModeState, true);
    option("pollInterval", 100);
    option("undoDepth", 200, function (cm, val) { return cm.doc.history.undoDepth = val; });
    option("historyEventDelay", 1250);
    option("viewportMargin", 10, function (cm) { return cm.refresh(); }, true);
    option("maxHighlightLength", 10000, resetModeState, true);
    option("moveInputWithCursor", true, function (cm, val) {
      if (!val) { cm.display.input.resetPosition(); }
    });

option("tabindex", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || ""; });
    option("autofocus", null);
    option("direction", "ltr", function (cm, val) { return cm.doc.setDirection(val); }, true);
    option("phrases", null);
  }

function guttersChanged(cm) {
    updateGutters(cm);
    regChange(cm);
    alignHorizontally(cm);
  }

function dragDropChanged(cm, value, old) {
    var wasOn = old && old != Init;
    if (!value != !wasOn) {
      var funcs = cm.display.dragFunctions;
      var toggle = value ? on : off;
      toggle(cm.display.scroller, "dragstart", funcs.start);
      toggle(cm.display.scroller, "dragenter", funcs.enter);
      toggle(cm.display.scroller, "dragover", funcs.over);
      toggle(cm.display.scroller, "dragleave", funcs.leave);
      toggle(cm.display.scroller, "drop", funcs.drop);
    }
  }

// A CodeMirror instance represents an editor. This is the object
  // that user code is usually dealing with.

function CodeMirror(place, options) {
    var this$1 = this;

if (!(this instanceof CodeMirror)) { return new CodeMirror(place, options) }

this.options = options = options ? copyObj(options) : {};
    // Determine effective options based on given values and defaults.
    copyObj(defaults, options, false);
    setGuttersForLineNumbers(options);

var doc = options.value;
    if (typeof doc == "string") { doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction); }
    else if (options.mode) { doc.modeOption = options.mode; }
    this.doc = doc;

var input = new CodeMirror.inputStyles[options.inputStyle](this);
    var display = this.display = new Display(place, doc, input);
    display.wrapper.CodeMirror = this;
    updateGutters(this);
    themeChanged(this);
    if (options.lineWrapping)
      { this.display.wrapper.className += " CodeMirror-wrap"; }
    initScrollbars(this);

this.state = {
      keyMaps: [],  // stores maps added by addKeyMap
      overlays: [], // highlighting overlays, as added by addOverlay
      modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info
      overwrite: false,
      delayingBlurEvent: false,
      focused: false,
      suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
      pasteIncoming: -1, cutIncoming: -1, // help recognize paste/cut edits in input.poll
      selectingText: false,
      draggingText: false,
      highlight: new Delayed(), // stores highlight worker timeout
      keySeq: null,  // Unfinished key sequence
      specialChars: null
    };

if (options.autofocus && !mobile) { display.input.focus(); }

// Override magic textarea content restore that IE sometimes does
    // on our hidden textarea on reload
    if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20); }

registerEventHandlers(this);
    ensureGlobalHandlers();

startOperation(this);
    this.curOp.forceUpdate = true;
    attachDoc(this, doc);

if ((options.autofocus && !mobile) || this.hasFocus())
      { setTimeout(bind(onFocus, this), 20); }
    else
      { onBlur(this); }

for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt))
      { optionHandlers[opt](this$1, options[opt], Init); } }
    maybeUpdateLineNumberWidth(this);
    if (options.finishInit) { options.finishInit(this); }
    for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1); }
    endOperation(this);
    // Suppress optimizelegibility in Webkit, since it breaks text
    // measuring on line wrapping boundaries.
    if (webkit && options.lineWrapping &&
        getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
      { display.lineDiv.style.textRendering = "auto"; }
  }

// The default configuration options.
  CodeMirror.defaults = defaults;
  // Functions to run when options are changed.
  CodeMirror.optionHandlers = optionHandlers;

// Attach the necessary event handlers when initializing the editor
  function registerEventHandlers(cm) {
    var d = cm.display;
    on(d.scroller, "mousedown", operation(cm, onMouseDown));
    // Older IE's will not fire a second mousedown for a double click
    if (ie && ie_version < 11)
      { on(d.scroller, "dblclick", operation(cm, function (e) {
        if (signalDOMEvent(cm, e)) { return }
        var pos = posFromMouse(cm, e);
        if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return }
        e_preventDefault(e);
        var word = cm.findWordAt(pos);
        extendSelection(cm.doc, word.anchor, word.head);
      })); }
    else
      { on(d.scroller, "dblclick", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }); }
    // Some browsers fire contextmenu *after* opening the menu, at
    // which point we can't mess with it anymore. Context menu is
    // handled in onMouseDown for these browsers.
    on(d.scroller, "contextmenu", function (e) { return onContextMenu(cm, e); });

// Used to suppress mouse event handling when a touch happens
    var touchFinished, prevTouch = {end: 0};
    function finishTouch() {
      if (d.activeTouch) {
        touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000);
        prevTouch = d.activeTouch;
        prevTouch.end = +new Date;
      }
    }
    function isMouseLikeTouchEvent(e) {
      if (e.touches.length != 1) { return false }
      var touch = e.touches[0];
      return touch.radiusX <= 1 && touch.radiusY <= 1
    }
    function farAway(touch, other) {
      if (other.left == null) { return true }
      var dx = other.left - touch.left, dy = other.top - touch.top;
      return dx * dx + dy * dy > 20 * 20
    }
    on(d.scroller, "touchstart", function (e) {
      if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) {
        d.input.ensurePolled();
        clearTimeout(touchFinished);
        var now = +new Date;
        d.activeTouch = {start: now, moved: false,
                         prev: now - prevTouch.end <= 300 ? prevTouch : null};
        if (e.touches.length == 1) {
          d.activeTouch.left = e.touches[0].pageX;
          d.activeTouch.top = e.touches[0].pageY;
        }
      }
    });
    on(d.scroller, "touchmove", function () {
      if (d.activeTouch) { d.activeTouch.moved = true; }
    });
    on(d.scroller, "touchend", function (e) {
      var touch = d.activeTouch;
      if (touch && !eventInWidget(d, e) && touch.left != null &&
          !touch.moved && new Date - touch.start < 300) {
        var pos = cm.coordsChar(d.activeTouch, "page"), range;
        if (!touch.prev || farAway(touch, touch.prev)) // Single tap
          { range = new Range(pos, pos); }
        else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
          { range = cm.findWordAt(pos); }
        else // Triple tap
          { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))); }
        cm.setSelection(range.anchor, range.head);
        cm.focus();
        e_preventDefault(e);
      }
      finishTouch();
    });
    on(d.scroller, "touchcancel", finishTouch);

// Sync scrolling between fake scrollbars and real scrollable
    // area, ensure viewport is updated when scrolling.
    on(d.scroller, "scroll", function () {
      if (d.scroller.clientHeight) {
        updateScrollTop(cm, d.scroller.scrollTop);
        setScrollLeft(cm, d.scroller.scrollLeft, true);
        signal(cm, "scroll", cm);
      }
    });

// Listen to wheel events in order to try and update the viewport on time.
    on(d.scroller, "mousewheel", function (e) { return onScrollWheel(cm, e); });
    on(d.scroller, "DOMMouseScroll", function (e) { return onScrollWheel(cm, e); });

// Prevent wrapper from ever scrolling
    on(d.wrapper, "scroll", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; });

d.dragFunctions = {
      enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e); }},
      over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e); }},
      start: function (e) { return onDragStart(cm, e); },
      drop: operation(cm, onDrop),
      leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm); }}
    };

var initHooks = [];
  CodeMirror.defineInitHook = function (f) { return initHooks.push(f); };

// Indent the given line. The how parameter can be "smart",
  // "add"/null, "subtract", or "prev". When aggressive is false
  // (typically set to true for forced single-line indents), empty
  // lines are not indented, and places where the mode returns Pass
  // are left alone.
  function indentLine(cm, n, how, aggressive) {
    var doc = cm.doc, state;
    if (how == null) { how = "add"; }
    if (how == "smart") {
      // Fall back to "prev" when the mode doesn't have an indentation
      // method.
      if (!doc.mode.indent) { how = "prev"; }
      else { state = getContextBefore(cm, n).state; }
    }

if (indentString != curSpaceString) {
      replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input");
      line.stateAfter = null;
      return true
    } else {
      // Ensure that, if the cursor was in the whitespace at the start
      // of the line, it is moved to the end of that space.
      for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) {
        var range = doc.sel.ranges[i$1];
        if (range.head.line == n && range.head.ch < curSpaceString.length) {
          var pos$1 = Pos(n, curSpaceString.length);
          replaceOneSelection(doc, i$1, new Range(pos$1, pos$1));
          break
        }
      }
    }
  }

// This will be set to a {lineWise: bool, text: [string]} object, so
  // that, when pasting, we know what kind of selections the copied
  // text was made out of.
  var lastCopied = null;

function setLastCopied(newLastCopied) {
    lastCopied = newLastCopied;
  }

function applyTextInput(cm, inserted, deleted, sel, origin) {
    var doc = cm.doc;
    cm.display.shift = false;
    if (!sel) { sel = doc.sel; }

ensureCursorVisible(cm);
    if (cm.curOp.updateInput < 2) { cm.curOp.updateInput = updateInput; }
    cm.curOp.typing = true;
    cm.state.pasteIncoming = cm.state.cutIncoming = -1;
  }

function triggerElectric(cm, inserted) {
    // When an 'electric' character is inserted, immediately trigger a reindent
    if (!cm.options.electricChars || !cm.options.smartIndent) { return }
    var sel = cm.doc.sel;

for (var i = sel.ranges.length - 1; i >= 0; i--) {
      var range$$1 = sel.ranges[i];
      if (range$$1.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range$$1.head.line)) { continue }
      var mode = cm.getModeAt(range$$1.head);
      var indented = false;
      if (mode.electricChars) {
        for (var j = 0; j < mode.electricChars.length; j++)
          { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {
            indented = indentLine(cm, range$$1.head.line, "smart");
            break
          } }
      } else if (mode.electricInput) {
        if (mode.electricInput.test(getLine(cm.doc, range$$1.head.line).text.slice(0, range$$1.head.ch)))
          { indented = indentLine(cm, range$$1.head.line, "smart"); }
      }
      if (indented) { signalLater(cm, "electricInput", cm, range$$1.head.line); }
    }
  }

function disableBrowserMagic(field, spellcheck, autocorrect, autocapitalize) {
    field.setAttribute("autocorrect", !!autocorrect);
    field.setAttribute("autocapitalize", !!autocapitalize);
    field.setAttribute("spellcheck", !!spellcheck);
  }

// The publicly visible API. Note that methodOp(f) means
  // 'wrap f in an operation, performed on its `this` parameter'.

// This is not the complete set of editor methods. Most of the
  // methods defined on the Doc type are also injected into
  // CodeMirror.prototype, for backwards compatibility and
  // convenience.

function addEditorMethods(CodeMirror) {
    var optionHandlers = CodeMirror.optionHandlers;

var helpers = CodeMirror.helpers = {};

CodeMirror.prototype = {
      constructor: CodeMirror,
      focus: function(){window.focus(); this.display.input.focus();},

setOption: function(option, value) {
        var options = this.options, old = options[option];
        if (options[option] == value && option != "mode") { return }
        options[option] = value;
        if (optionHandlers.hasOwnProperty(option))
          { operation(this, optionHandlers[option])(this, value, old); }
        signal(this, "optionChange", this, option);
      },

getOption: function(option) {return this.options[option]},
      getDoc: function() {return this.doc},

addKeyMap: function(map$$1, bottom) {
        this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map$$1));
      },
      removeKeyMap: function(map$$1) {
        var maps = this.state.keyMaps;
        for (var i = 0; i < maps.length; ++i)
          { if (maps[i] == map$$1 || maps[i].name == map$$1) {
            maps.splice(i, 1);
            return true
          } }
      },

addOverlay: methodOp(function(spec, options) {
        var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec);
        if (mode.startState) { throw new Error("Overlays may not be stateful.") }
        insertSorted(this.state.overlays,
                     {mode: mode, modeSpec: spec, opaque: options && options.opaque,
                      priority: (options && options.priority) || 0},
                     function (overlay) { return overlay.priority; });
        this.state.modeGen++;
        regChange(this);
      }),
      removeOverlay: methodOp(function(spec) {
        var this$1 = this;

var overlays = this.state.overlays;
        for (var i = 0; i < overlays.length; ++i) {
          var cur = overlays[i].modeSpec;
          if (cur == spec || typeof spec == "string" && cur.name == spec) {
            overlays.splice(i, 1);
            this$1.state.modeGen++;
            regChange(this$1);
            return
          }
        }
      }),

indentLine: methodOp(function(n, dir, aggressive) {
        if (typeof dir != "string" && typeof dir != "number") {
          if (dir == null) { dir = this.options.smartIndent ? "smart" : "prev"; }
          else { dir = dir ? "add" : "subtract"; }
        }
        if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive); }
      }),
      indentSelection: methodOp(function(how) {
        var this$1 = this;

// Fetch the parser token for a given character. Useful for hacks
      // that want to inspect the mode state (say, for completion).
      getTokenAt: function(pos, precise) {
        return takeToken(this, pos, precise)
      },

getLineTokens: function(line, precise) {
        return takeToken(this, Pos(line), precise, true)
      },

getTokenTypeAt: function(pos) {
        pos = clipPos(this.doc, pos);
        var styles = getLineStyles(this, getLine(this.doc, pos.line));
        var before = 0, after = (styles.length - 1) / 2, ch = pos.ch;
        var type;
        if (ch == 0) { type = styles[2]; }
        else { for (;;) {
          var mid = (before + after) >> 1;
          if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid; }
          else if (styles[mid * 2 + 1] < ch) { before = mid + 1; }
          else { type = styles[mid * 2 + 2]; break }
        } }
        var cut = type ? type.indexOf("overlay ") : -1;
        return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1)
      },

getModeAt: function(pos) {
        var mode = this.doc.mode;
        if (!mode.innerMode) { return mode }
        return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode
      },

getHelper: function(pos, type) {
        return this.getHelpers(pos, type)[0]
      },

getHelpers: function(pos, type) {
        var this$1 = this;

getStateAfter: function(line, precise) {
        var doc = this.doc;
        line = clipLine(doc, line == null ? doc.first + doc.size - 1: line);
        return getContextBefore(this, line + 1, precise).state
      },

cursorCoords: function(start, mode) {
        var pos, range$$1 = this.doc.sel.primary();
        if (start == null) { pos = range$$1.head; }
        else if (typeof start == "object") { pos = clipPos(this.doc, start); }
        else { pos = start ? range$$1.from() : range$$1.to(); }
        return cursorCoords(this, pos, mode || "page")
      },

charCoords: function(pos, mode) {
        return charCoords(this, clipPos(this.doc, pos), mode || "page")
      },

coordsChar: function(coords, mode) {
        coords = fromCoordSystem(this, coords, mode || "page");
        return coordsChar(this, coords.left, coords.top)
      },

lineAtHeight: function(height, mode) {
        height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top;
        return lineAtHeight(this.doc, height + this.display.viewOffset)
      },
      heightAtLine: function(line, mode, includeWidgets) {
        var end = false, lineObj;
        if (typeof line == "number") {
          var last = this.doc.first + this.doc.size - 1;
          if (line < this.doc.first) { line = this.doc.first; }
          else if (line > last) { line = last; end = true; }
          lineObj = getLine(this.doc, line);
        } else {
          lineObj = line;
        }
        return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page", includeWidgets || end).top +
          (end ? this.doc.height - heightAtLine(lineObj) : 0)
      },

defaultTextHeight: function() { return textHeight(this.display) },
      defaultCharWidth: function() { return charWidth(this.display) },

getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}},

addWidget: function(pos, node, scroll, vert, horiz) {
        var display = this.display;
        pos = cursorCoords(this, clipPos(this.doc, pos));
        var top = pos.bottom, left = pos.left;
        node.style.position = "absolute";
        node.setAttribute("cm-ignore-events", "true");
        this.display.input.setUneditable(node);
        display.sizer.appendChild(node);
        if (vert == "over") {
          top = pos.top;
        } else if (vert == "above" || vert == "near") {
          var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),
          hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth);
          // Default to positioning above (if specified and possible); otherwise default to positioning below
          if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)
            { top = pos.top - node.offsetHeight; }
          else if (pos.bottom + node.offsetHeight <= vspace)
            { top = pos.bottom; }
          if (left + node.offsetWidth > hspace)
            { left = hspace - node.offsetWidth; }
        }
        node.style.top = top + "px";
        node.style.left = node.style.right = "";
        if (horiz == "right") {
          left = display.sizer.clientWidth - node.offsetWidth;
          node.style.right = "0px";
        } else {
          if (horiz == "left") { left = 0; }
          else if (horiz == "middle") { left = (display.sizer.clientWidth - node.offsetWidth) / 2; }
          node.style.left = left + "px";
        }
        if (scroll)
          { scrollIntoView(this, {left: left, top: top, right: left + node.offsetWidth, bottom: top + node.offsetHeight}); }
      },

triggerOnKeyDown: methodOp(onKeyDown),
      triggerOnKeyPress: methodOp(onKeyPress),
      triggerOnKeyUp: onKeyUp,
      triggerOnMouseDown: methodOp(onMouseDown),

execCommand: function(cmd) {
        if (commands.hasOwnProperty(cmd))
          { return commands[cmd].call(null, this) }
      },

triggerElectric: methodOp(function(text) { triggerElectric(this, text); }),

findPosH: function(from, amount, unit, visually) {
        var this$1 = this;

moveH: methodOp(function(dir, unit) {
        var this$1 = this;

this.extendSelectionsBy(function (range$$1) {
          if (this$1.display.shift || this$1.doc.extend || range$$1.empty())
            { return findPosH(this$1.doc, range$$1.head, dir, unit, this$1.options.rtlMoveVisually) }
          else
            { return dir < 0 ? range$$1.from() : range$$1.to() }
        }, sel_move);
      }),

deleteH: methodOp(function(dir, unit) {
        var sel = this.doc.sel, doc = this.doc;
        if (sel.somethingSelected())
          { doc.replaceSelection("", null, "+delete"); }
        else
          { deleteNearSelection(this, function (range$$1) {
            var other = findPosH(doc, range$$1.head, dir, unit, false);
            return dir < 0 ? {from: other, to: range$$1.head} : {from: range$$1.head, to: other}
          }); }
      }),

findPosV: function(from, amount, unit, goalColumn) {
        var this$1 = this;

moveV: methodOp(function(dir, unit) {
        var this$1 = this;

// Find the word at the given position (as returned by coordsChar).
      findWordAt: function(pos) {
        var doc = this.doc, line = getLine(doc, pos.line).text;
        var start = pos.ch, end = pos.ch;
        if (line) {
          var helper = this.getHelper(pos, "wordChars");
          if ((pos.sticky == "before" || end == line.length) && start) { --start; } else { ++end; }
          var startChar = line.charAt(start);
          var check = isWordChar(startChar, helper)
            ? function (ch) { return isWordChar(ch, helper); }
            : /\s/.test(startChar) ? function (ch) { return /\s/.test(ch); }
            : function (ch) { return (!/\s/.test(ch) && !isWordChar(ch)); };
          while (start > 0 && check(line.charAt(start - 1))) { --start; }
          while (end < line.length && check(line.charAt(end))) { ++end; }
        }
        return new Range(Pos(pos.line, start), Pos(pos.line, end))
      },

toggleOverwrite: function(value) {
        if (value != null && value == this.state.overwrite) { return }
        if (this.state.overwrite = !this.state.overwrite)
          { addClass(this.display.cursorDiv, "CodeMirror-overwrite"); }
        else
          { rmClass(this.display.cursorDiv, "CodeMirror-overwrite"); }

signal(this, "overwriteToggle", this, this.state.overwrite);
      },
      hasFocus: function() { return this.display.input.getField() == activeElt() },
      isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) },

scrollTo: methodOp(function (x, y) { scrollToCoords(this, x, y); }),
      getScrollInfo: function() {
        var scroller = this.display.scroller;
        return {left: scroller.scrollLeft, top: scroller.scrollTop,
                height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,
                width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,
                clientHeight: displayHeight(this), clientWidth: displayWidth(this)}
      },

scrollIntoView: methodOp(function(range$$1, margin) {
        if (range$$1 == null) {
          range$$1 = {from: this.doc.sel.primary().head, to: null};
          if (margin == null) { margin = this.options.cursorScrollMargin; }
        } else if (typeof range$$1 == "number") {
          range$$1 = {from: Pos(range$$1, 0), to: null};
        } else if (range$$1.from == null) {
          range$$1 = {from: range$$1, to: null};
        }
        if (!range$$1.to) { range$$1.to = range$$1.from; }
        range$$1.margin = margin || 0;

if (range$$1.from.line != null) {
          scrollToRange(this, range$$1);
        } else {
          scrollToCoordsRange(this, range$$1.from, range$$1.to, range$$1.margin);
        }
      }),

setSize: methodOp(function(width, height) {
        var this$1 = this;

operation: function(f){return runInOp(this, f)},
      startOperation: function(){return startOperation(this)},
      endOperation: function(){return endOperation(this)},

refresh: methodOp(function() {
        var oldHeight = this.display.cachedTextHeight;
        regChange(this);
        this.curOp.forceUpdate = true;
        clearCaches(this);
        scrollToCoords(this, this.doc.scrollLeft, this.doc.scrollTop);
        updateGutterSpace(this);
        if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)
          { estimateLineHeights(this); }
        signal(this, "refresh", this);
      }),

swapDoc: methodOp(function(doc) {
        var old = this.doc;
        old.cm = null;
        attachDoc(this, doc);
        clearCaches(this);
        this.display.input.reset();
        scrollToCoords(this, doc.scrollLeft, doc.scrollTop);
        this.curOp.forceScroll = true;
        signalLater(this, "swapDoc", this, old);
        return old
      }),

phrase: function(phraseText) {
        var phrases = this.options.phrases;
        return phrases && Object.prototype.hasOwnProperty.call(phrases, phraseText) ? phrases[phraseText] : phraseText
      },

getInputField: function(){return this.display.input.getField()},
      getWrapperElement: function(){return this.display.wrapper},
      getScrollerElement: function(){return this.display.scroller},
      getGutterElement: function(){return this.display.gutters}
    };
    eventMixin(CodeMirror);

CodeMirror.registerHelper = function(type, name, value) {
      if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []}; }
      helpers[type][name] = value;
    };
    CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {
      CodeMirror.registerHelper(type, name, value);
      helpers[type]._global.push({pred: predicate, val: value});
    };
  }

// Used for horizontal relative motion. Dir is -1 or 1 (left or
  // right), unit can be "char", "column" (like char, but doesn't
  // cross line boundaries), "word" (across next word), or "group" (to
  // the start of next group of word or non-word-non-whitespace
  // chars). The visually param controls whether, in right-to-left
  // text, direction 1 means to move towards the next index in the
  // string, or towards the character to the right of the current
  // position. The resulting position will have a hitSide=true
  // property if it reached the end of the document.
  function findPosH(doc, pos, dir, unit, visually) {
    var oldPos = pos;
    var origDir = dir;
    var lineObj = getLine(doc, pos.line);
    function findNextLine() {
      var l = pos.line + dir;
      if (l < doc.first || l >= doc.first + doc.size) { return false }
      pos = new Pos(l, pos.ch, pos.sticky);
      return lineObj = getLine(doc, l)
    }
    function moveOnce(boundToLine) {
      var next;
      if (visually) {
        next = moveVisually(doc.cm, lineObj, pos, dir);
      } else {
        next = moveLogically(lineObj, pos, dir);
      }
      if (next == null) {
        if (!boundToLine && findNextLine())
          { pos = endOfLine(visually, doc.cm, lineObj, pos.line, dir); }
        else
          { return false }
      } else {
        pos = next;
      }
      return true
    }

if (unit == "char") {
      moveOnce();
    } else if (unit == "column") {
      moveOnce(true);
    } else if (unit == "word" || unit == "group") {
      var sawType = null, group = unit == "group";
      var helper = doc.cm && doc.cm.getHelper(pos, "wordChars");
      for (var first = true;; first = false) {
        if (dir < 0 && !moveOnce(!first)) { break }
        var cur = lineObj.text.charAt(pos.ch) || "\n";
        var type = isWordChar(cur, helper) ? "w"
          : group && cur == "\n" ? "n"
          : !group || /\s/.test(cur) ? null
          : "p";
        if (group && !first && !type) { type = "s"; }
        if (sawType && sawType != type) {
          if (dir < 0) {dir = 1; moveOnce(); pos.sticky = "after";}
          break
        }

if (type) { sawType = type; }
        if (dir > 0 && !moveOnce(!first)) { break }
      }
    }
    var result = skipAtomic(doc, pos, oldPos, origDir, true);
    if (equalCursorPos(oldPos, result)) { result.hitSide = true; }
    return result
  }

// For relative vertical movement. Dir may be -1 or 1. Unit can be
  // "page" or "line". The resulting position will have a hitSide=true
  // property if it reached the end of the document.
  function findPosV(cm, pos, dir, unit) {
    var doc = cm.doc, x = pos.left, y;
    if (unit == "page") {
      var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight);
      var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3);
      y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount;

} else if (unit == "line") {
      y = dir > 0 ? pos.bottom + 3 : pos.top - 3;
    }
    var target;
    for (;;) {
      target = coordsChar(cm, x, y);
      if (!target.outside) { break }
      if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break }
      y += dir * 5;
    }
    return target
  }

// CONTENTEDITABLE INPUT STYLE

var ContentEditableInput = function(cm) {
    this.cm = cm;
    this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null;
    this.polling = new Delayed();
    this.composing = null;
    this.gracePeriod = false;
    this.readDOMTimeout = null;
  };

ContentEditableInput.prototype.init = function (display) {
      var this$1 = this;

var input = this, cm = input.cm;
    var div = input.div = display.lineDiv;
    disableBrowserMagic(div, cm.options.spellcheck, cm.options.autocorrect, cm.options.autocapitalize);

on(div, "paste", function (e) {
      if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }
      // IE doesn't fire input events, so we schedule a read for the pasted content in this way
      if (ie_version <= 11) { setTimeout(operation(cm, function () { return this$1.updateFromDOM(); }), 20); }
    });

on(div, "compositionstart", function (e) {
      this$1.composing = {data: e.data, done: false};
    });
    on(div, "compositionupdate", function (e) {
      if (!this$1.composing) { this$1.composing = {data: e.data, done: false}; }
    });
    on(div, "compositionend", function (e) {
      if (this$1.composing) {
        if (e.data != this$1.composing.data) { this$1.readFromDOMSoon(); }
        this$1.composing.done = true;
      }
    });

on(div, "touchstart", function () { return input.forceCompositionEnd(); });

on(div, "input", function () {
      if (!this$1.composing) { this$1.readFromDOMSoon(); }
    });

ContentEditableInput.prototype.prepareSelection = function () {
    var result = prepareSelection(this.cm, false);
    result.focus = this.cm.state.focused;
    return result
  };

ContentEditableInput.prototype.showSelection = function (info, takeFocus) {
    if (!info || !this.cm.display.view.length) { return }
    if (info.focus || takeFocus) { this.showPrimarySelection(); }
    this.showMultipleSelections(info);
  };

ContentEditableInput.prototype.getSelection = function () {
    return this.cm.display.wrapper.ownerDocument.getSelection()
  };

ContentEditableInput.prototype.showPrimarySelection = function () {
    var sel = this.getSelection(), cm = this.cm, prim = cm.doc.sel.primary();
    var from = prim.from(), to = prim.to();

if (cm.display.viewTo == cm.display.viewFrom || from.line >= cm.display.viewTo || to.line < cm.display.viewFrom) {
      sel.removeAllRanges();
      return
    }

var curAnchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);
    var curFocus = domToPos(cm, sel.focusNode, sel.focusOffset);
    if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&
        cmp(minPos(curAnchor, curFocus), from) == 0 &&
        cmp(maxPos(curAnchor, curFocus), to) == 0)
      { return }

if (!start || !end) {
      sel.removeAllRanges();
      return
    }

ContentEditableInput.prototype.startGracePeriod = function () {
      var this$1 = this;

clearTimeout(this.gracePeriod);
    this.gracePeriod = setTimeout(function () {
      this$1.gracePeriod = false;
      if (this$1.selectionChanged())
        { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }); }
    }, 20);
  };

ContentEditableInput.prototype.showMultipleSelections = function (info) {
    removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors);
    removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection);
  };

ContentEditableInput.prototype.rememberSelection = function () {
    var sel = this.getSelection();
    this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset;
    this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset;
  };

ContentEditableInput.prototype.selectionInEditor = function () {
    var sel = this.getSelection();
    if (!sel.rangeCount) { return false }
    var node = sel.getRangeAt(0).commonAncestorContainer;
    return contains(this.div, node)
  };

ContentEditableInput.prototype.focus = function () {
    if (this.cm.options.readOnly != "nocursor") {
      if (!this.selectionInEditor())
        { this.showSelection(this.prepareSelection(), true); }
      this.div.focus();
    }
  };
  ContentEditableInput.prototype.blur = function () { this.div.blur(); };
  ContentEditableInput.prototype.getField = function () { return this.div };

ContentEditableInput.prototype.supportsTouch = function () { return true };

ContentEditableInput.prototype.receivedFocus = function () {
    var input = this;
    if (this.selectionInEditor())
      { this.pollSelection(); }
    else
      { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }); }

function poll() {
      if (input.cm.state.focused) {
        input.pollSelection();
        input.polling.set(input.cm.options.pollInterval, poll);
      }
    }
    this.polling.set(this.cm.options.pollInterval, poll);
  };

ContentEditableInput.prototype.selectionChanged = function () {
    var sel = this.getSelection();
    return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||
      sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset
  };

ContentEditableInput.prototype.pollSelection = function () {
    if (this.readDOMTimeout != null || this.gracePeriod || !this.selectionChanged()) { return }
    var sel = this.getSelection(), cm = this.cm;
    // On Android Chrome (version 56, at least), backspacing into an
    // uneditable block element will put the cursor in that element,
    // and then, because it's not editable, hide the virtual keyboard.
    // Because Android doesn't allow us to actually detect backspace
    // presses in a sane way, this code checks for when that happens
    // and simulates a backspace press in this case.
    if (android && chrome && this.cm.options.gutters.length && isInGutter(sel.anchorNode)) {
      this.cm.triggerOnKeyDown({type: "keydown", keyCode: 8, preventDefault: Math.abs});
      this.blur();
      this.focus();
      return
    }
    if (this.composing) { return }
    this.rememberSelection();
    var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);
    var head = domToPos(cm, sel.focusNode, sel.focusOffset);
    if (anchor && head) { runInOp(cm, function () {
      setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll);
      if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true; }
    }); }
  };

ContentEditableInput.prototype.pollContent = function () {
    if (this.readDOMTimeout != null) {
      clearTimeout(this.readDOMTimeout);
      this.readDOMTimeout = null;
    }

var fromIndex, fromLine, fromNode;
    if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {
      fromLine = lineNo(display.view[0].line);
      fromNode = display.view[0].node;
    } else {
      fromLine = lineNo(display.view[fromIndex].line);
      fromNode = display.view[fromIndex - 1].node.nextSibling;
    }
    var toIndex = findViewIndex(cm, to.line);
    var toLine, toNode;
    if (toIndex == display.view.length - 1) {
      toLine = display.viewTo - 1;
      toNode = display.lineDiv.lastChild;
    } else {
      toLine = lineNo(display.view[toIndex + 1].line) - 1;
      toNode = display.view[toIndex + 1].node.previousSibling;
    }

if (!fromNode) { return false }
    var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine));
    var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length));
    while (newText.length > 1 && oldText.length > 1) {
      if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine--; }
      else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++; }
      else { break }
    }

newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\u200b+/, "");
    newText[0] = newText[0].slice(cutFront).replace(/\u200b+$/, "");

var chFrom = Pos(fromLine, cutFront);
    var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0);
    if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {
      replaceRange(cm.doc, newText, chFrom, chTo, "+input");
      return true
    }
  };

ContentEditableInput.prototype.ensurePolled = function () {
    this.forceCompositionEnd();
  };
  ContentEditableInput.prototype.reset = function () {
    this.forceCompositionEnd();
  };
  ContentEditableInput.prototype.forceCompositionEnd = function () {
    if (!this.composing) { return }
    clearTimeout(this.readDOMTimeout);
    this.composing = null;
    this.updateFromDOM();
    this.div.blur();
    this.div.focus();
  };
  ContentEditableInput.prototype.readFromDOMSoon = function () {
      var this$1 = this;

if (this.readDOMTimeout != null) { return }
    this.readDOMTimeout = setTimeout(function () {
      this$1.readDOMTimeout = null;
      if (this$1.composing) {
        if (this$1.composing.done) { this$1.composing = null; }
        else { return }
      }
      this$1.updateFromDOM();
    }, 80);
  };

ContentEditableInput.prototype.updateFromDOM = function () {
      var this$1 = this;

if (this.cm.isReadOnly() || !this.pollContent())
      { runInOp(this.cm, function () { return regChange(this$1.cm); }); }
  };

ContentEditableInput.prototype.setUneditable = function (node) {
    node.contentEditable = "false";
  };

ContentEditableInput.prototype.onKeyPress = function (e) {
    if (e.charCode == 0 || this.composing) { return }
    e.preventDefault();
    if (!this.cm.isReadOnly())
      { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0); }
  };

ContentEditableInput.prototype.readOnlyChanged = function (val) {
    this.div.contentEditable = String(val != "nocursor");
  };

ContentEditableInput.prototype.onContextMenu = function () {};
  ContentEditableInput.prototype.resetPosition = function () {};

ContentEditableInput.prototype.needsContentAttribute = true;

function posToDOM(cm, pos) {
    var view = findViewForLine(cm, pos.line);
    if (!view || view.hidden) { return null }
    var line = getLine(cm.doc, pos.line);
    var info = mapFromLineView(view, line, pos.line);

var order = getOrder(line, cm.doc.direction), side = "left";
    if (order) {
      var partPos = getBidiPartAt(order, pos.ch);
      side = partPos % 2 ? "right" : "left";
    }
    var result = nodeAndOffsetInLineMap(info.map, pos.ch, side);
    result.offset = result.collapse == "right" ? result.end : result.start;
    return result
  }

function isInGutter(node) {
    for (var scan = node; scan; scan = scan.parentNode)
      { if (/CodeMirror-gutter-wrapper/.test(scan.className)) { return true } }
    return false
  }

function badPos(pos, bad) { if (bad) { pos.bad = true; } return pos }

if (isBlock) { close(); }
        for (var i = 0; i < node.childNodes.length; i++)
          { walk(node.childNodes[i]); }

if (/^(pre|p)$/i.test(node.nodeName)) { extraLinebreak = true; }
        if (isBlock) { closing = true; }
      } else if (node.nodeType == 3) {
        addText(node.nodeValue.replace(/\u200b/g, "").replace(/\u00a0/g, " "));
      }
    }
    for (;;) {
      walk(from);
      if (from == to) { break }
      from = from.nextSibling;
      extraLinebreak = false;
    }
    return text
  }

// FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems
    for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {
      found = find(after, after.firstChild, 0);
      if (found)
        { return badPos(Pos(found.line, found.ch - dist), bad) }
      else
        { dist += after.textContent.length; }
    }
    for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) {
      found = find(before, before.firstChild, -1);
      if (found)
        { return badPos(Pos(found.line, found.ch + dist$1), bad) }
      else
        { dist$1 += before.textContent.length; }
    }
  }

// TEXTAREA INPUT STYLE

var TextareaInput = function(cm) {
    this.cm = cm;
    // See input.poll and input.reset
    this.prevInput = "";

// Flag that indicates whether we expect input to appear real soon
    // now (after some event like 'keypress' or 'input') and are
    // polling intensively.
    this.pollingFast = false;
    // Self-resetting timeout for the poller
    this.polling = new Delayed();
    // Used to work around IE issue with selection being forgotten when focus moves away from textarea
    this.hasSelection = false;
    this.composing = null;
  };

TextareaInput.prototype.init = function (display) {
      var this$1 = this;

var input = this, cm = this.cm;
    this.createField(display);
    var te = this.textarea;

display.wrapper.insertBefore(this.wrapper, display.wrapper.firstChild);

// Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)
    if (ios) { te.style.width = "0px"; }

on(te, "input", function () {
      if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null; }
      input.poll();
    });

on(te, "paste", function (e) {
      if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }

cm.state.pasteIncoming = +new Date;
      input.fastPoll();
    });

on(display.scroller, "paste", function (e) {
      if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return }
      if (!te.dispatchEvent) {
        cm.state.pasteIncoming = +new Date;
        input.focus();
        return
      }

// Pass the `paste` event to the textarea so it's handled by its event listener.
      var event = new Event("paste");
      event.clipboardData = e.clipboardData;
      te.dispatchEvent(event);
    });

// Prevent normal selection in the editor (we handle our own)
    on(display.lineSpace, "selectstart", function (e) {
      if (!eventInWidget(display, e)) { e_preventDefault(e); }
    });

on(te, "compositionstart", function () {
      var start = cm.getCursor("from");
      if (input.composing) { input.composing.range.clear(); }
      input.composing = {
        start: start,
        range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"})
      };
    });
    on(te, "compositionend", function () {
      if (input.composing) {
        input.poll();
        input.composing.range.clear();
        input.composing = null;
      }
    });
  };

TextareaInput.prototype.createField = function (_display) {
    // Wraps and hides input textarea
    this.wrapper = hiddenTextarea();
    // The semihidden textarea that is focused when the editor is
    // focused, and receives input.
    this.textarea = this.wrapper.firstChild;
  };

TextareaInput.prototype.prepareSelection = function () {
    // Redraw the selection and/or cursor
    var cm = this.cm, display = cm.display, doc = cm.doc;
    var result = prepareSelection(cm);

// Move the hidden textarea near the cursor to prevent scrolling artifacts
    if (cm.options.moveInputWithCursor) {
      var headPos = cursorCoords(cm, doc.sel.primary().head, "div");
      var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect();
      result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
                                          headPos.top + lineOff.top - wrapOff.top));
      result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
                                           headPos.left + lineOff.left - wrapOff.left));
    }

return result
  };

TextareaInput.prototype.showSelection = function (drawn) {
    var cm = this.cm, display = cm.display;
    removeChildrenAndAdd(display.cursorDiv, drawn.cursors);
    removeChildrenAndAdd(display.selectionDiv, drawn.selection);
    if (drawn.teTop != null) {
      this.wrapper.style.top = drawn.teTop + "px";
      this.wrapper.style.left = drawn.teLeft + "px";
    }
  };

// Reset the input to correspond to the selection (or to be empty,
  // when not typing and nothing is selected)
  TextareaInput.prototype.reset = function (typing) {
    if (this.contextMenuPending || this.composing) { return }
    var cm = this.cm;
    if (cm.somethingSelected()) {
      this.prevInput = "";
      var content = cm.getSelection();
      this.textarea.value = content;
      if (cm.state.focused) { selectInput(this.textarea); }
      if (ie && ie_version >= 9) { this.hasSelection = content; }
    } else if (!typing) {
      this.prevInput = this.textarea.value = "";
      if (ie && ie_version >= 9) { this.hasSelection = null; }
    }
  };

TextareaInput.prototype.getField = function () { return this.textarea };

TextareaInput.prototype.supportsTouch = function () { return false };

TextareaInput.prototype.focus = function () {
    if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) {
      try { this.textarea.focus(); }
      catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM
    }
  };

TextareaInput.prototype.blur = function () { this.textarea.blur(); };

TextareaInput.prototype.resetPosition = function () {
    this.wrapper.style.top = this.wrapper.style.left = 0;
  };

TextareaInput.prototype.receivedFocus = function () { this.slowPoll(); };

// Poll for input changes, using the normal rate of polling. This
  // runs as long as the editor is focused.
  TextareaInput.prototype.slowPoll = function () {
      var this$1 = this;

if (this.pollingFast) { return }
    this.polling.set(this.cm.options.pollInterval, function () {
      this$1.poll();
      if (this$1.cm.state.focused) { this$1.slowPoll(); }
    });
  };

// When an event has just come in that is likely to add or change
  // something in the input textarea, we poll faster, to ensure that
  // the change appears on the screen quickly.
  TextareaInput.prototype.fastPoll = function () {
    var missed = false, input = this;
    input.pollingFast = true;
    function p() {
      var changed = input.poll();
      if (!changed && !missed) {missed = true; input.polling.set(60, p);}
      else {input.pollingFast = false; input.slowPoll();}
    }
    input.polling.set(20, p);
  };

// Read input from the textarea, and update the document to match.
  // When something is selected, it is present in the textarea, and
  // selected (unless it is huge, in which case a placeholder is
  // used). When nothing is selected, the cursor sits after previously
  // seen text (can be empty), which is stored in prevInput (we must
  // not reset the textarea when typing, because that breaks IME).
  TextareaInput.prototype.poll = function () {
      var this$1 = this;

var cm = this.cm, input = this.textarea, prevInput = this.prevInput;
    // Since this is called a *lot*, try to bail out as cheaply as
    // possible when it is clear that nothing happened. hasSelection
    // will be the case when there is a lot of text in the textarea,
    // in which case reading its value would be expensive.
    if (this.contextMenuPending || !cm.state.focused ||
        (hasSelection(input) && !prevInput && !this.composing) ||
        cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)
      { return false }

var text = input.value;
    // If nothing changed, bail.
    if (text == prevInput && !cm.somethingSelected()) { return false }
    // Work around nonsensical selection resetting in IE9/10, and
    // inexplicable appearance of private area unicode characters on
    // some key combos in Mac (#2689).
    if (ie && ie_version >= 9 && this.hasSelection === text ||
        mac && /[\uf700-\uf7ff]/.test(text)) {
      cm.display.input.reset();
      return false
    }

if (cm.doc.sel == cm.display.selForContextMenu) {
      var first = text.charCodeAt(0);
      if (first == 0x200b && !prevInput) { prevInput = "\u200b"; }
      if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo") }
    }
    // Find the part of the input that is actually new
    var same = 0, l = Math.min(prevInput.length, text.length);
    while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same; }

runInOp(cm, function () {
      applyTextInput(cm, text.slice(same), prevInput.length - same,
                     null, this$1.composing ? "*compose" : null);

// Don't leave long text in the textarea, since it makes further polling slow
      if (text.length > 1000 || text.indexOf("\n") > -1) { input.value = this$1.prevInput = ""; }
      else { this$1.prevInput = text; }

if (this$1.composing) {
        this$1.composing.range.clear();
        this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor("to"),
                                           {className: "CodeMirror-composing"});
      }
    });
    return true
  };

TextareaInput.prototype.ensurePolled = function () {
    if (this.pollingFast && this.poll()) { this.pollingFast = false; }
  };

TextareaInput.prototype.onKeyPress = function () {
    if (ie && ie_version >= 9) { this.hasSelection = null; }
    this.fastPoll();
  };

TextareaInput.prototype.onContextMenu = function (e) {
    var input = this, cm = input.cm, display = cm.display, te = input.textarea;
    if (input.contextMenuPending) { input.contextMenuPending(); }
    var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop;
    if (!pos || presto) { return } // Opera is difficult.

// Reset the current text selection only if the click is done outside of the selection
    // and 'resetSelectionOnContextMenu' option is true.
    var reset = cm.options.resetSelectionOnContextMenu;
    if (reset && cm.doc.sel.contains(pos) == -1)
      { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll); }

// Select-all will be greyed out if there's nothing to select, so
    // this adds a zero-width space so that we can later check whether
    // it got selected.
    function prepareSelectAllHack() {
      if (te.selectionStart != null) {
        var selected = cm.somethingSelected();
        var extval = "\u200b" + (selected ? te.value : "");
        te.value = "\u21da"; // Used to catch context-menu undo
        te.value = extval;
        input.prevInput = selected ? "" : "\u200b";
        te.selectionStart = 1; te.selectionEnd = extval.length;
        // Re-set this, in case some other handler touched the
        // selection in the meantime.
        display.selForContextMenu = cm.doc.sel;
      }
    }
    function rehide() {
      if (input.contextMenuPending != rehide) { return }
      input.contextMenuPending = false;
      input.wrapper.style.cssText = oldWrapperCSS;
      te.style.cssText = oldCSS;
      if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos); }

// Try to detect the user choosing select-all
      if (te.selectionStart != null) {
        if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack(); }
        var i = 0, poll = function () {
          if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&
              te.selectionEnd > 0 && input.prevInput == "\u200b") {
            operation(cm, selectAll)(cm);
          } else if (i++ < 10) {
            display.detectingSelectAll = setTimeout(poll, 500);
          } else {
            display.selForContextMenu = null;
            display.input.reset();
          }
        };
        display.detectingSelectAll = setTimeout(poll, 200);
      }
    }

if (ie && ie_version >= 9) { prepareSelectAllHack(); }
    if (captureRightClick) {
      e_stop(e);
      var mouseup = function () {
        off(window, "mouseup", mouseup);
        setTimeout(rehide, 20);
      };
      on(window, "mouseup", mouseup);
    } else {
      setTimeout(rehide, 50);
    }
  };

TextareaInput.prototype.readOnlyChanged = function (val) {
    if (!val) { this.reset(); }
    this.textarea.disabled = val == "nocursor";
  };

TextareaInput.prototype.setUneditable = function () {};

TextareaInput.prototype.needsContentAttribute = false;

function save() {textarea.value = cm.getValue();}

var realSubmit;
    if (textarea.form) {
      on(textarea.form, "submit", save);
      // Deplorable hack to make the submit method do the right thing.
      if (!options.leaveSubmitMethodAlone) {
        var form = textarea.form;
        realSubmit = form.submit;
        try {
          var wrappedSubmit = form.submit = function () {
            save();
            form.submit = realSubmit;
            form.submit();
            form.submit = wrappedSubmit;
          };
        } catch(e) {}
      }
    }

options.finishInit = function (cm) {
      cm.save = save;
      cm.getTextArea = function () { return textarea; };
      cm.toTextArea = function () {
        cm.toTextArea = isNaN; // Prevent this from being ran twice
        save();
        textarea.parentNode.removeChild(cm.getWrapperElement());
        textarea.style.display = "";
        if (textarea.form) {
          off(textarea.form, "submit", save);
          if (typeof textarea.form.submit == "function")
            { textarea.form.submit = realSubmit; }
        }
      };
    };

textarea.style.display = "none";
    var cm = CodeMirror(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); },
      options);
    return cm
  }

function addLegacyProps(CodeMirror) {
    CodeMirror.off = off;
    CodeMirror.on = on;
    CodeMirror.wheelEventPixels = wheelEventPixels;
    CodeMirror.Doc = Doc;
    CodeMirror.splitLines = splitLinesAuto;
    CodeMirror.countColumn = countColumn;
    CodeMirror.findColumn = findColumn;
    CodeMirror.isWordChar = isWordCharBasic;
    CodeMirror.Pass = Pass;
    CodeMirror.signal = signal;
    CodeMirror.Line = Line;
    CodeMirror.changeEnd = changeEnd;
    CodeMirror.scrollbarModel = scrollbarModel;
    CodeMirror.Pos = Pos;
    CodeMirror.cmpPos = cmp;
    CodeMirror.modes = modes;
    CodeMirror.mimeModes = mimeModes;
    CodeMirror.resolveMode = resolveMode;
    CodeMirror.getMode = getMode;
    CodeMirror.modeExtensions = modeExtensions;
    CodeMirror.extendMode = extendMode;
    CodeMirror.copyState = copyState;
    CodeMirror.startState = startState;
    CodeMirror.innerMode = innerMode;
    CodeMirror.commands = commands;
    CodeMirror.keyMap = keyMap;
    CodeMirror.keyName = keyName;
    CodeMirror.isModifierKey = isModifierKey;
    CodeMirror.lookupKey = lookupKey;
    CodeMirror.normalizeKeyMap = normalizeKeyMap;
    CodeMirror.StringStream = StringStream;
    CodeMirror.SharedTextMarker = SharedTextMarker;
    CodeMirror.TextMarker = TextMarker;
    CodeMirror.LineWidget = LineWidget;
    CodeMirror.e_preventDefault = e_preventDefault;
    CodeMirror.e_stopPropagation = e_stopPropagation;
    CodeMirror.e_stop = e_stop;
    CodeMirror.addClass = addClass;
    CodeMirror.contains = contains;
    CodeMirror.rmClass = rmClass;
    CodeMirror.keyNames = keyNames;
  }

// EDITOR CONSTRUCTOR

defineOptions(CodeMirror);

addEditorMethods(CodeMirror);

// Set up methods on CodeMirror's prototype to redirect to the editor's document.
  var dontDelegate = "iter insert remove copy getEditor constructor".split(" ");
  for (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)
    { CodeMirror.prototype[prop] = (function(method) {
      return function() {return method.apply(this.doc, arguments)}
    })(Doc.prototype[prop]); } }

eventMixin(Doc);
  CodeMirror.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput};

// Extra arguments are stored as the mode's dependencies, which is
  // used by (legacy) mechanisms like loadmode.js to automatically
  // load a mode. (Preferred mechanism is the require/define calls.)
  CodeMirror.defineMode = function(name/*, mode, …*/) {
    if (!CodeMirror.defaults.mode && name != "null") { CodeMirror.defaults.mode = name; }
    defineMode.apply(this, arguments);
  };

CodeMirror.defineMIME = defineMIME;

// Minimal default mode.
  CodeMirror.defineMode("null", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); });
  CodeMirror.defineMIME("text/plain", "null");

// EXTENSIONS

CodeMirror.defineExtension = function (name, func) {
    CodeMirror.prototype[name] = func;
  };
  CodeMirror.defineDocExtension = function (name, func) {
    Doc.prototype[name] = func;
  };

CodeMirror.fromTextArea = fromTextArea;

addLegacyProps(CodeMirror);

CodeMirror.version = "5.45.0";

return CodeMirror;

})));

/***/ }),
/* 245 */
/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = function (it) {
  return toString.call(it).slice(8, -1);
};

/***/ }),
/* 246 */
/***/ (function(module, exports, __webpack_require__) {

// optional / simple context binding
var aFunction = __webpack_require__(802);
module.exports = function (fn, that, length) {
  aFunction(fn);
  if (that === undefined) return fn;
  switch (length) {
    case 1: return function (a) {
      return fn.call(that, a);
    };
    case 2: return function (a, b) {
      return fn.call(that, a, b);
    };
    case 3: return function (a, b, c) {
      return fn.call(that, a, b, c);
    };
  }
  return function (/* ...args */) {
    return fn.apply(that, arguments);
  };
};

/***/ }),
/* 247 */
/***/ (function(module, exports) {

// 7.2.1 RequireObjectCoercible(argument)
module.exports = function (it) {
  if (it == undefined) throw TypeError("Can't call method on  " + it);
  return it;
};

/***/ }),
/* 248 */
/***/ (function(module, exports) {

// IE 8- don't enum bug keys
module.exports = (
  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
).split(',');

/***/ }),
/* 249 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
var anObject = __webpack_require__(100);
var dPs = __webpack_require__(817);
var enumBugKeys = __webpack_require__(248);
var IE_PROTO = __webpack_require__(254)('IE_PROTO');
var Empty = function () { /* empty */ };
var PROTOTYPE = 'prototype';

// Create object with fake `null` prototype: use iframe Object with cleared prototype
var createDict = function () {
  // Thrash, waste and sodomy: IE GC bug
  var iframe = __webpack_require__(388)('iframe');
  var i = enumBugKeys.length;
  var lt = '<';
  var gt = '>';
  var iframeDocument;
  iframe.style.display = 'none';
  __webpack_require__(808).appendChild(iframe);
  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
  // createDict = iframe.contentWindow.Object;
  // html.removeChild(iframe);
  iframeDocument = iframe.contentWindow.document;
  iframeDocument.open();
  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
  iframeDocument.close();
  createDict = iframeDocument.F;
  while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
  return createDict();
};

module.exports = Object.create || function create(O, Properties) {
  var result;
  if (O !== null) {
    Empty[PROTOTYPE] = anObject(O);
    result = new Empty();
    Empty[PROTOTYPE] = null;
    // add "__proto__" for Object.getPrototypeOf polyfill
    result[IE_PROTO] = O;
  } else result = createDict();
  return Properties === undefined ? result : dPs(result, Properties);
};

/***/ }),
/* 250 */
/***/ (function(module, exports, __webpack_require__) {

var pIE = __webpack_require__(163);
var createDesc = __webpack_require__(129);
var toIObject = __webpack_require__(82);
var toPrimitive = __webpack_require__(257);
var has = __webpack_require__(81);
var IE8_DOM_DEFINE = __webpack_require__(389);
var gOPD = Object.getOwnPropertyDescriptor;

exports.f = __webpack_require__(68) ? gOPD : function getOwnPropertyDescriptor(O, P) {
  O = toIObject(O);
  P = toPrimitive(P, true);
  if (IE8_DOM_DEFINE) try {
    return gOPD(O, P);
  } catch (e) { /* empty */ }
  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
};

/***/ }),
/* 251 */
/***/ (function(module, exports) {

exports.f = Object.getOwnPropertySymbols;

/***/ }),
/* 252 */
/***/ (function(module, exports, __webpack_require__) {

// most Object methods by ES6 should accept primitives
var $export = __webpack_require__(69);
var core = __webpack_require__(34);
var fails = __webpack_require__(101);
module.exports = function (KEY, exec) {
  var fn = (core.Object || {})[KEY] || Object[KEY];
  var exp = {};
  exp[KEY] = exec(fn);
  $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);
};

/***/ }),
/* 253 */
/***/ (function(module, exports, __webpack_require__) {

var def = __webpack_require__(71).f;
var has = __webpack_require__(81);
var TAG = __webpack_require__(55)('toStringTag');

module.exports = function (it, tag, stat) {
  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
};

/***/ }),
/* 254 */
/***/ (function(module, exports, __webpack_require__) {

var shared = __webpack_require__(255)('keys');
var uid = __webpack_require__(164);
module.exports = function (key) {
  return shared[key] || (shared[key] = uid(key));
};

/***/ }),
/* 255 */
/***/ (function(module, exports, __webpack_require__) {

var core = __webpack_require__(34);
var global = __webpack_require__(70);
var SHARED = '__core-js_shared__';
var store = global[SHARED] || (global[SHARED] = {});

(module.exports = function (key, value) {
  return store[key] || (store[key] = value !== undefined ? value : {});
})('versions', []).push({
  version: core.version,
  mode: __webpack_require__(162) ? 'pure' : 'global',
  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
});

/***/ }),
/* 256 */
/***/ (function(module, exports) {

// 7.1.4 ToInteger
var ceil = Math.ceil;
var floor = Math.floor;
module.exports = function (it) {
  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
};

/***/ }),
/* 257 */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.1 ToPrimitive(input [, PreferredType])
var isObject = __webpack_require__(103);
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
module.exports = function (it, S) {
  if (!isObject(it)) return it;
  var fn, val;
  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
  throw TypeError("Can't convert object to primitive value");
};

/***/ }),
/* 258 */
/***/ (function(module, exports, __webpack_require__) {

/***/ }),
/* 259 */
/***/ (function(module, exports, __webpack_require__) {

exports.f = __webpack_require__(55);

/***/ }),
/* 260 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isCssAnimationSupported; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof__ = __webpack_require__(161);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__Event__ = __webpack_require__(398);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_component_classes__ = __webpack_require__(386);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_component_classes___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_component_classes__);

var isCssAnimationSupported = __WEBPACK_IMPORTED_MODULE_1__Event__["a" /* default */].endEvents.length !== 0;
var capitalPrefixes = ['Webkit', 'Moz', 'O',
// ms is special .... !
'ms'];
var prefixes = ['-webkit-', '-moz-', '-o-', 'ms-', ''];

function clearBrowserBugTimeout(node) {
  if (node.rcEndAnimTimeout) {
    clearTimeout(node.rcEndAnimTimeout);
    node.rcEndAnimTimeout = null;
  }
}

var cssAnimation = function cssAnimation(node, transitionName, endCallback) {
  var nameIsObj = (typeof transitionName === 'undefined' ? 'undefined' : __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof___default()(transitionName)) === 'object';
  var className = nameIsObj ? transitionName.name : transitionName;
  var activeClassName = nameIsObj ? transitionName.active : transitionName + '-active';
  var end = endCallback;
  var start = void 0;
  var active = void 0;
  var nodeClasses = __WEBPACK_IMPORTED_MODULE_2_component_classes___default()(node);

if (endCallback && Object.prototype.toString.call(endCallback) === '[object Object]') {
    end = endCallback.end;
    start = endCallback.start;
    active = endCallback.active;
  }

if (node.rcEndListener) {
    node.rcEndListener();
  }

node.rcEndListener = function (e) {
    if (e && e.target !== node) {
      return;
    }

if (node.rcAnimTimeout) {
      clearTimeout(node.rcAnimTimeout);
      node.rcAnimTimeout = null;
    }

clearBrowserBugTimeout(node);

nodeClasses.remove(className);
    nodeClasses.remove(activeClassName);

__WEBPACK_IMPORTED_MODULE_1__Event__["a" /* default */].removeEndEventListener(node, node.rcEndListener);
    node.rcEndListener = null;

// Usually this optional end is used for informing an owner of
    // a leave animation and telling it to remove the child.
    if (end) {
      end();
    }
  };

__WEBPACK_IMPORTED_MODULE_1__Event__["a" /* default */].addEndEventListener(node, node.rcEndListener);

if (start) {
    start();
  }
  nodeClasses.add(className);

node.rcAnimTimeout = setTimeout(function () {
    node.rcAnimTimeout = null;
    nodeClasses.add(activeClassName);
    if (active) {
      setTimeout(active, 0);
    }
    fixBrowserByTimeout(node);
    // 30ms for firefox
  }, 30);

return {
    stop: function stop() {
      if (node.rcEndListener) {
        node.rcEndListener();
      }
    }
  };
};

cssAnimation.style = function (node, style, callback) {
  if (node.rcEndListener) {
    node.rcEndListener();
  }

node.rcEndListener = function (e) {
    if (e && e.target !== node) {
      return;
    }

if (node.rcAnimTimeout) {
      clearTimeout(node.rcAnimTimeout);
      node.rcAnimTimeout = null;
    }

clearBrowserBugTimeout(node);

__WEBPACK_IMPORTED_MODULE_1__Event__["a" /* default */].removeEndEventListener(node, node.rcEndListener);
    node.rcEndListener = null;

// Usually this optional callback is used for informing an owner of
    // a leave animation and telling it to remove the child.
    if (callback) {
      callback();
    }
  };

__WEBPACK_IMPORTED_MODULE_1__Event__["a" /* default */].addEndEventListener(node, node.rcEndListener);

node.rcAnimTimeout = setTimeout(function () {
    for (var s in style) {
      if (style.hasOwnProperty(s)) {
        node.style[s] = style[s];
      }
    }
    node.rcAnimTimeout = null;
    fixBrowserByTimeout(node);
  }, 0);
};

cssAnimation.setTransition = function (node, p, value) {
  var property = p;
  var v = value;
  if (value === undefined) {
    v = property;
    property = '';
  }
  property = property || '';
  capitalPrefixes.forEach(function (prefix) {
    node.style[prefix + 'Transition' + property] = v;
  });
};

cssAnimation.isCssAnimationSupported = isCssAnimationSupported;

/* harmony default export */ __webpack_exports__["b"] = (cssAnimation);

/***/ }),
/* 261 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
// css base code, injected by the css-loader
module.exports = function(useSourceMap) {
	var list = [];

// return the list of modules as css string
	list.toString = function toString() {
		return this.map(function (item) {
			var content = cssWithMappingToString(item, useSourceMap);
			if(item[2]) {
				return "@media " + item[2] + "{" + content + "}";
			} else {
				return content;
			}
		}).join("");
	};

// import a list of modules into the list
	list.i = function(modules, mediaQuery) {
		if(typeof modules === "string")
			modules = [[null, modules, ""]];
		var alreadyImportedModules = {};
		for(var i = 0; i < this.length; i++) {
			var id = this[i][0];
			if(typeof id === "number")
				alreadyImportedModules[id] = true;
		}
		for(i = 0; i < modules.length; i++) {
			var item = modules[i];
			// skip already imported module
			// this implementation is not 100% perfect for weird media query combinations
			//  when a module is imported multiple times with different media queries.
			//  I hope this will never occur (Hey this way we have smaller bundles)
			if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
				if(mediaQuery && !item[2]) {
					item[2] = mediaQuery;
				} else if(mediaQuery) {
					item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
				}
				list.push(item);
			}
		}
	};
	return list;
};

function cssWithMappingToString(item, useSourceMap) {
	var content = item[1] || '';
	var cssMapping = item[3];
	if (!cssMapping) {
		return content;
	}

if (useSourceMap) {
		var sourceMapping = toComment(cssMapping);
		var sourceURLs = cssMapping.sources.map(function (source) {
			return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'
		});

return [content].concat(sourceURLs).concat([sourceMapping]).join('\n');
	}

return [content].join('\n');
}

// Adapted from convert-source-map (MIT)
function toComment(sourceMap) {
  var base64 = new Buffer(JSON.stringify(sourceMap)).toString('base64');
  var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;

return '/*# ' + data + ' */';
}

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(789).Buffer))

/***/ }),
/* 262 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = isDisposable;

function isDisposable(obj) {
  return Boolean(obj && typeof obj.dispose === 'function');
}

module.exports = exports['default'];

/***/ }),
/* 263 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
 * EvEmitter v1.1.0
 * Lil' event emitter
 * MIT License
 */

/* jshint unused: true, undef: true, strict: true */

( function( global, factory ) {
  // universal module definition
  /* jshint strict: false */ /* globals define, module, window */
  if ( true ) {
    // AMD - RequireJS
    !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
				__WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if ( typeof module == 'object' && module.exports ) {
    // CommonJS - Browserify, Webpack
    module.exports = factory();
  } else {
    // Browser globals
    global.EvEmitter = factory();
  }

}( typeof window != 'undefined' ? window : this, function() {

"use strict";

function EvEmitter() {}

var proto = EvEmitter.prototype;

proto.on = function( eventName, listener ) {
  if ( !eventName || !listener ) {
    return;
  }
  // set events hash
  var events = this._events = this._events || {};
  // set listeners array
  var listeners = events[ eventName ] = events[ eventName ] || [];
  // only add once
  if ( listeners.indexOf( listener ) == -1 ) {
    listeners.push( listener );
  }

return this;
};

proto.once = function( eventName, listener ) {
  if ( !eventName || !listener ) {
    return;
  }
  // add event
  this.on( eventName, listener );
  // set once flag
  // set onceEvents hash
  var onceEvents = this._onceEvents = this._onceEvents || {};
  // set onceListeners object
  var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] || {};
  // set flag
  onceListeners[ listener ] = true;

return this;
};

proto.off = function( eventName, listener ) {
  var listeners = this._events && this._events[ eventName ];
  if ( !listeners || !listeners.length ) {
    return;
  }
  var index = listeners.indexOf( listener );
  if ( index != -1 ) {
    listeners.splice( index, 1 );
  }

return this;
};

proto.emitEvent = function( eventName, args ) {
  var listeners = this._events && this._events[ eventName ];
  if ( !listeners || !listeners.length ) {
    return;
  }
  // copy over to avoid interference if .off() in listener
  listeners = listeners.slice(0);
  args = args || [];
  // once stuff
  var onceListeners = this._onceEvents && this._onceEvents[ eventName ];

for ( var i=0; i < listeners.length; i++ ) {
    var listener = listeners[i]
    var isOnce = onceListeners && onceListeners[ listener ];
    if ( isOnce ) {
      // remove listener
      // remove before trigger to prevent recursion
      this.off( eventName, listener );
      // unset once flag
      delete onceListeners[ listener ];
    }
    // trigger listener
    listener.apply( this, args );
  }

return this;
};

proto.allOff = function() {
  delete this._events;
  delete this._onceEvents;
};

return EvEmitter;

}));

/***/ }),
/* 264 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var implementation = __webpack_require__(944);

module.exports = Function.prototype.bind || implementation;

/***/ }),
/* 265 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 * getSize v2.0.3
 * measure size of elements
 * MIT license
 */

/* jshint browser: true, strict: true, undef: true, unused: true */
/* globals console: false */

( function( window, factory ) {
  /* jshint strict: false */ /* globals define, module */
  if ( true ) {
    // AMD
    !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
				__WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if ( typeof module == 'object' && module.exports ) {
    // CommonJS
    module.exports = factory();
  } else {
    // browser global
    window.getSize = factory();
  }

})( window, function factory() {
'use strict';

// -------------------------- helpers -------------------------- //

// get a number from a string, not a percentage
function getStyleSize( value ) {
  var num = parseFloat( value );
  // not a percent like '100%', and a number
  var isValid = value.indexOf('%') == -1 && !isNaN( num );
  return isValid && num;
}

function noop() {}

var logError = typeof console == 'undefined' ? noop :
  function( message ) {
    console.error( message );
  };

// -------------------------- measurements -------------------------- //

var measurements = [
  'paddingLeft',
  'paddingRight',
  'paddingTop',
  'paddingBottom',
  'marginLeft',
  'marginRight',
  'marginTop',
  'marginBottom',
  'borderLeftWidth',
  'borderRightWidth',
  'borderTopWidth',
  'borderBottomWidth'
];

var measurementsLength = measurements.length;

// -------------------------- getStyle -------------------------- //

/**
 * getStyle, get style of element, check for Firefox bug
 * https://bugzilla.mozilla.org/show_bug.cgi?id=548397
 */
function getStyle( elem ) {
  var style = getComputedStyle( elem );
  if ( !style ) {
    logError( 'Style returned ' + style +
      '. Are you running this code in a hidden iframe on Firefox? ' +
      'See https://bit.ly/getsizebug1' );
  }
  return style;
}

// -------------------------- setup -------------------------- //

var isSetup = false;

var isBoxSizeOuter;

/**
 * setup
 * check isBoxSizerOuter
 * do on first getSize() rather than on page load for Firefox bug
 */
function setup() {
  // setup once
  if ( isSetup ) {
    return;
  }
  isSetup = true;

// -------------------------- box sizing -------------------------- //

/**
   * Chrome & Safari measure the outer-width on style.width on border-box elems
   * IE11 & Firefox<29 measures the inner-width
   */
  var div = document.createElement('div');
  div.style.width = '200px';
  div.style.padding = '1px 2px 3px 4px';
  div.style.borderStyle = 'solid';
  div.style.borderWidth = '1px 2px 3px 4px';
  div.style.boxSizing = 'border-box';

var body = document.body || document.documentElement;
  body.appendChild( div );
  var style = getStyle( div );
  // round value for browser zoom. desandro/masonry#928
  isBoxSizeOuter = Math.round( getStyleSize( style.width ) ) == 200;
  getSize.isBoxSizeOuter = isBoxSizeOuter;

body.removeChild( div );
}

// -------------------------- getSize -------------------------- //

function getSize( elem ) {
  setup();

// use querySeletor if elem is string
  if ( typeof elem == 'string' ) {
    elem = document.querySelector( elem );
  }

// do not proceed on non-objects
  if ( !elem || typeof elem != 'object' || !elem.nodeType ) {
    return;
  }

var style = getStyle( elem );

// if hidden, everything is 0
  if ( style.display == 'none' ) {
    return getZeroSize();
  }

var size = {};
  size.width = elem.offsetWidth;
  size.height = elem.offsetHeight;

var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';

// get all measurements
  for ( var i=0; i < measurementsLength; i++ ) {
    var measurement = measurements[i];
    var value = style[ measurement ];
    var num = parseFloat( value );
    // any 'auto', 'medium' value will be 0
    size[ measurement ] = !isNaN( num ) ? num : 0;
  }

var paddingWidth = size.paddingLeft + size.paddingRight;
  var paddingHeight = size.paddingTop + size.paddingBottom;
  var marginWidth = size.marginLeft + size.marginRight;
  var marginHeight = size.marginTop + size.marginBottom;
  var borderWidth = size.borderLeftWidth + size.borderRightWidth;
  var borderHeight = size.borderTopWidth + size.borderBottomWidth;

var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;

// overwrite width and height if we can get it from style
  var styleWidth = getStyleSize( style.width );
  if ( styleWidth !== false ) {
    size.width = styleWidth +
      // add padding and border unless it's already including it
      ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
  }

var styleHeight = getStyleSize( style.height );
  if ( styleHeight !== false ) {
    size.height = styleHeight +
      // add padding and border unless it's already including it
      ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
  }

size.innerWidth = size.width - ( paddingWidth + borderWidth );
  size.innerHeight = size.height - ( paddingHeight + borderHeight );

size.outerWidth = size.width + marginWidth;
  size.outerHeight = size.height + marginHeight;

return size;
}

return getSize;

});

/***/ }),
/* 266 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var hasSymbols = __webpack_require__(414);

module.exports = function hasToStringTagShams() {
	return hasSymbols() && !!Symbol.toStringTag;
};

/***/ }),
/* 267 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.addEventListener = addEventListener;
exports.removeEventListener = removeEventListener;
exports.getHashPath = getHashPath;
exports.replaceHashPath = replaceHashPath;
exports.getWindowPath = getWindowPath;
exports.go = go;
exports.getUserConfirmation = getUserConfirmation;
exports.supportsHistory = supportsHistory;
exports.supportsGoWithoutReloadUsingHash = supportsGoWithoutReloadUsingHash;

function addEventListener(node, event, listener) {
  if (node.addEventListener) {
    node.addEventListener(event, listener, false);
  } else {
    node.attachEvent('on' + event, listener);
  }
}

function removeEventListener(node, event, listener) {
  if (node.removeEventListener) {
    node.removeEventListener(event, listener, false);
  } else {
    node.detachEvent('on' + event, listener);
  }
}

function getHashPath() {
  // We can't use window.location.hash here because it's not
  // consistent across browsers - Firefox will pre-decode it!
  return window.location.href.split('#')[1] || '';
}

function replaceHashPath(path) {
  window.location.replace(window.location.pathname + window.location.search + '#' + path);
}

function getWindowPath() {
  return window.location.pathname + window.location.search + window.location.hash;
}

function go(n) {
  if (n) window.history.go(n);
}

function getUserConfirmation(message, callback) {
  callback(window.confirm(message));
}

/**
 * Returns true if the HTML5 history API is supported. Taken from Modernizr.
 *
 * https://github.com/Modernizr/Modernizr/blob/master/LICENSE
 * https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
 * changed to avoid false negatives for Windows Phones: https://github.com/rackt/react-router/issues/586
 */

function supportsHistory() {
  var ua = navigator.userAgent;
  if ((ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) && ua.indexOf('Mobile Safari') !== -1 && ua.indexOf('Chrome') === -1 && ua.indexOf('Windows Phone') === -1) {
    return false;
  }
  return window.history && 'pushState' in window.history;
}

/**
 * Returns false if using go(n) with hash history causes a full page reload.
 */

function supportsGoWithoutReloadUsingHash() {
  var ua = navigator.userAgent;
  return ua.indexOf('Firefox') === -1;
}

/***/ }),
/* 268 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

function deprecate(fn, message) {
  return function () {
    process.env.NODE_ENV !== 'production' ? _warning2['default'](false, '[history] ' + message) : undefined;
    return fn.apply(this, arguments);
  };
}

exports['default'] = deprecate;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 269 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

function runTransitionHook(hook, location, callback) {
  var result = hook(location, callback);

if (hook.length < 2) {
    // Assume the hook runs synchronously and automatically
    // call the callback with the return value.
    callback(result);
  } else {
    process.env.NODE_ENV !== 'production' ? _warning2['default'](result === undefined, 'You should not "return" in a transition hook with a callback argument; call the callback instead') : undefined;
  }
}

exports['default'] = runTransitionHook;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 270 */
/***/ (function(module, exports, __webpack_require__) {

var baseCreate = __webpack_require__(279),
    baseLodash = __webpack_require__(283);

/** Used as references for the maximum length and index of an array. */
var MAX_ARRAY_LENGTH = 4294967295;

/**
 * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
 *
 * @private
 * @constructor
 * @param {*} value The value to wrap.
 */
function LazyWrapper(value) {
  this.__wrapped__ = value;
  this.__actions__ = [];
  this.__dir__ = 1;
  this.__filtered__ = false;
  this.__iteratees__ = [];
  this.__takeCount__ = MAX_ARRAY_LENGTH;
  this.__views__ = [];
}

// Ensure `LazyWrapper` is an instance of `baseLodash`.
LazyWrapper.prototype = baseCreate(baseLodash.prototype);
LazyWrapper.prototype.constructor = LazyWrapper;

module.exports = LazyWrapper;

/***/ }),
/* 271 */
/***/ (function(module, exports, __webpack_require__) {

var baseCreate = __webpack_require__(279),
    baseLodash = __webpack_require__(283);

/**
 * The base constructor for creating `lodash` wrapper objects.
 *
 * @private
 * @param {*} value The value to wrap.
 * @param {boolean} [chainAll] Enable explicit method chain sequences.
 */
function LodashWrapper(value, chainAll) {
  this.__wrapped__ = value;
  this.__actions__ = [];
  this.__chain__ = !!chainAll;
  this.__index__ = 0;
  this.__values__ = undefined;
}

LodashWrapper.prototype = baseCreate(baseLodash.prototype);
LodashWrapper.prototype.constructor = LodashWrapper;

module.exports = LodashWrapper;

/***/ }),
/* 272 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(85),
    root = __webpack_require__(45);

/* Built-in method references that are verified to be native. */
var Map = getNative(root, 'Map');

module.exports = Map;

/***/ }),
/* 273 */
/***/ (function(module, exports, __webpack_require__) {

var mapCacheClear = __webpack_require__(1045),
    mapCacheDelete = __webpack_require__(1046),
    mapCacheGet = __webpack_require__(1047),
    mapCacheHas = __webpack_require__(1048),
    mapCacheSet = __webpack_require__(1049);

/**
 * Creates a map cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function MapCache(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

// Add methods to `MapCache`.
MapCache.prototype.clear = mapCacheClear;
MapCache.prototype['delete'] = mapCacheDelete;
MapCache.prototype.get = mapCacheGet;
MapCache.prototype.has = mapCacheHas;
MapCache.prototype.set = mapCacheSet;

module.exports = MapCache;

/***/ }),
/* 274 */
/***/ (function(module, exports, __webpack_require__) {

var ListCache = __webpack_require__(171),
    stackClear = __webpack_require__(1061),
    stackDelete = __webpack_require__(1062),
    stackGet = __webpack_require__(1063),
    stackHas = __webpack_require__(1064),
    stackSet = __webpack_require__(1065);

/**
 * Creates a stack cache object to store key-value pairs.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function Stack(entries) {
  var data = this.__data__ = new ListCache(entries);
  this.size = data.size;
}

// Add methods to `Stack`.
Stack.prototype.clear = stackClear;
Stack.prototype['delete'] = stackDelete;
Stack.prototype.get = stackGet;
Stack.prototype.has = stackHas;
Stack.prototype.set = stackSet;

module.exports = Stack;

/***/ }),
/* 275 */
/***/ (function(module, exports, __webpack_require__) {

var baseIndexOf = __webpack_require__(978);

/**
 * A specialized version of `_.includes` for arrays without support for
 * specifying an index to search from.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
function arrayIncludes(array, value) {
  var length = array == null ? 0 : array.length;
  return !!length && baseIndexOf(array, value, 0) > -1;
}

module.exports = arrayIncludes;

/***/ }),
/* 276 */
/***/ (function(module, exports) {

/**
 * This function is like `arrayIncludes` except that it accepts a comparator.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @param {Function} comparator The comparator invoked per element.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
function arrayIncludesWith(array, value, comparator) {
  var index = -1,
      length = array == null ? 0 : array.length;

while (++index < length) {
    if (comparator(value, array[index])) {
      return true;
    }
  }
  return false;
}

module.exports = arrayIncludesWith;

/***/ }),
/* 277 */
/***/ (function(module, exports) {

/**
 * Appends the elements of `values` to `array`.
 *
 * @private
 * @param {Array} array The array to modify.
 * @param {Array} values The values to append.
 * @returns {Array} Returns `array`.
 */
function arrayPush(array, values) {
  var index = -1,
      length = values.length,
      offset = array.length;

while (++index < length) {
    array[offset + index] = values[index];
  }
  return array;
}

module.exports = arrayPush;

/***/ }),
/* 278 */
/***/ (function(module, exports, __webpack_require__) {

var baseAssignValue = __webpack_require__(426),
    eq = __webpack_require__(136);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Assigns `value` to `key` of `object` if the existing value is not equivalent
 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */
function assignValue(object, key, value) {
  var objValue = object[key];
  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
      (value === undefined && !(key in object))) {
    baseAssignValue(object, key, value);
  }
}

module.exports = assignValue;

/***/ }),
/* 279 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(46);

/** Built-in value references. */
var objectCreate = Object.create;

/**
 * The base implementation of `_.create` without support for assigning
 * properties to the created object.
 *
 * @private
 * @param {Object} proto The object to inherit from.
 * @returns {Object} Returns the new object.
 */
var baseCreate = (function() {
  function object() {}
  return function(proto) {
    if (!isObject(proto)) {
      return {};
    }
    if (objectCreate) {
      return objectCreate(proto);
    }
    object.prototype = proto;
    var result = new object;
    object.prototype = undefined;
    return result;
  };
}());

module.exports = baseCreate;

/***/ }),
/* 280 */
/***/ (function(module, exports, __webpack_require__) {

var arrayPush = __webpack_require__(277),
    isFlattenable = __webpack_require__(1036);

/**
 * The base implementation of `_.flatten` with support for restricting flattening.
 *
 * @private
 * @param {Array} array The array to flatten.
 * @param {number} depth The maximum recursion depth.
 * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
 * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
 * @param {Array} [result=[]] The initial result value.
 * @returns {Array} Returns the new flattened array.
 */
function baseFlatten(array, depth, predicate, isStrict, result) {
  var index = -1,
      length = array.length;

predicate || (predicate = isFlattenable);
  result || (result = []);

while (++index < length) {
    var value = array[index];
    if (depth > 0 && predicate(value)) {
      if (depth > 1) {
        // Recursively flatten arrays (susceptible to call stack limits).
        baseFlatten(value, depth - 1, predicate, isStrict, result);
      } else {
        arrayPush(result, value);
      }
    } else if (!isStrict) {
      result[result.length] = value;
    }
  }
  return result;
}

module.exports = baseFlatten;

/***/ }),
/* 281 */
/***/ (function(module, exports, __webpack_require__) {

var castPath = __webpack_require__(175),
    toKey = __webpack_require__(135);

/**
 * The base implementation of `_.get` without support for default values.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array|string} path The path of the property to get.
 * @returns {*} Returns the resolved value.
 */
function baseGet(object, path) {
  path = castPath(path, object);

var index = 0,
      length = path.length;

while (object != null && index < length) {
    object = object[toKey(path[index++])];
  }
  return (index && index == length) ? object : undefined;
}

module.exports = baseGet;

/***/ }),
/* 282 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsEqualDeep = __webpack_require__(981),
    isObjectLike = __webpack_require__(47);

/**
 * The base implementation of `_.isEqual` which supports partial comparisons
 * and tracks traversed objects.
 *
 * @private
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @param {boolean} bitmask The bitmask flags.
 *  1 - Unordered comparison
 *  2 - Partial comparison
 * @param {Function} [customizer] The function to customize comparisons.
 * @param {Object} [stack] Tracks traversed `value` and `other` objects.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 */
function baseIsEqual(value, other, bitmask, customizer, stack) {
  if (value === other) {
    return true;
  }
  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
    return value !== value && other !== other;
  }
  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
}

module.exports = baseIsEqual;

/***/ }),
/* 283 */
/***/ (function(module, exports) {

/**
 * The function whose prototype chain sequence wrappers inherit from.
 *
 * @private
 */
function baseLodash() {
  // No operation performed.
}

module.exports = baseLodash;

/***/ }),
/* 284 */
/***/ (function(module, exports, __webpack_require__) {

var Uint8Array = __webpack_require__(421);

/**
 * Creates a clone of `arrayBuffer`.
 *
 * @private
 * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
 * @returns {ArrayBuffer} Returns the cloned array buffer.
 */
function cloneArrayBuffer(arrayBuffer) {
  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
  return result;
}

module.exports = cloneArrayBuffer;

/***/ }),
/* 285 */
/***/ (function(module, exports, __webpack_require__) {

var overArg = __webpack_require__(450);

/** Built-in value references. */
var getPrototype = overArg(Object.getPrototypeOf, Object);

module.exports = getPrototype;

/***/ }),
/* 286 */
/***/ (function(module, exports, __webpack_require__) {

var arrayFilter = __webpack_require__(424),
    stubArray = __webpack_require__(456);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Built-in value references. */
var propertyIsEnumerable = objectProto.propertyIsEnumerable;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeGetSymbols = Object.getOwnPropertySymbols;

/**
 * Creates an array of the own enumerable symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of symbols.
 */
var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
  if (object == null) {
    return [];
  }
  object = Object(object);
  return arrayFilter(nativeGetSymbols(object), function(symbol) {
    return propertyIsEnumerable.call(object, symbol);
  });
};

module.exports = getSymbols;

/***/ }),
/* 287 */
/***/ (function(module, exports) {

/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;

/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;

/**
 * Checks if `value` is a valid array-like index.
 *
 * @private
 * @param {*} value The value to check.
 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
 */
function isIndex(value, length) {
  var type = typeof value;
  length = length == null ? MAX_SAFE_INTEGER : length;

return !!length &&
    (type == 'number' ||
      (type != 'symbol' && reIsUint.test(value))) &&
        (value > -1 && value % 1 == 0 && value < length);
}

module.exports = isIndex;

/***/ }),
/* 288 */
/***/ (function(module, exports, __webpack_require__) {

var isArray = __webpack_require__(27),
    isSymbol = __webpack_require__(183);

/** Used to match property names within property paths. */
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
    reIsPlainProp = /^\w*$/;

/**
 * Checks if `value` is a property name and not a property path.
 *
 * @private
 * @param {*} value The value to check.
 * @param {Object} [object] The object to query keys on.
 * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
 */
function isKey(value, object) {
  if (isArray(value)) {
    return false;
  }
  var type = typeof value;
  if (type == 'number' || type == 'symbol' || type == 'boolean' ||
      value == null || isSymbol(value)) {
    return true;
  }
  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
    (object != null && value in Object(object));
}

module.exports = isKey;

/***/ }),
/* 289 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = __webpack_require__(440);

/** Detect free variable `exports`. */
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;

/** Detect free variable `process` from Node.js. */
var freeProcess = moduleExports && freeGlobal.process;

/** Used to access faster Node.js helpers. */
var nodeUtil = (function() {
  try {
    // Use `util.types` for Node.js 10+.
    var types = freeModule && freeModule.require && freeModule.require('util').types;

if (types) {
      return types;
    }

// Legacy `process.binding('util')` for Node.js < 10.
    return freeProcess && freeProcess.binding && freeProcess.binding('util');
  } catch (e) {}
}());

module.exports = nodeUtil;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(201)(module)))

/***/ }),
/* 290 */
/***/ (function(module, exports) {

/**
 * Converts `set` to an array of its values.
 *
 * @private
 * @param {Object} set The set to convert.
 * @returns {Array} Returns the values.
 */
function setToArray(set) {
  var index = -1,
      result = Array(set.size);

set.forEach(function(value) {
    result[++index] = value;
  });
  return result;
}

module.exports = setToArray;

/***/ }),
/* 291 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(46),
    now = __webpack_require__(1090),
    toNumber = __webpack_require__(1094);

/** Error message constants. */
var FUNC_ERROR_TEXT = 'Expected a function';

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max,
    nativeMin = Math.min;

/**
 * Creates a debounced function that delays invoking `func` until after `wait`
 * milliseconds have elapsed since the last time the debounced function was
 * invoked. The debounced function comes with a `cancel` method to cancel
 * delayed `func` invocations and a `flush` method to immediately invoke them.
 * Provide `options` to indicate whether `func` should be invoked on the
 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
 * with the last arguments provided to the debounced function. Subsequent
 * calls to the debounced function return the result of the last `func`
 * invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is
 * invoked on the trailing edge of the timeout only if the debounced function
 * is invoked more than once during the `wait` timeout.
 *
 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
 *
 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
 * for details over the differences between `_.debounce` and `_.throttle`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to debounce.
 * @param {number} [wait=0] The number of milliseconds to delay.
 * @param {Object} [options={}] The options object.
 * @param {boolean} [options.leading=false]
 *  Specify invoking on the leading edge of the timeout.
 * @param {number} [options.maxWait]
 *  The maximum time `func` is allowed to be delayed before it's invoked.
 * @param {boolean} [options.trailing=true]
 *  Specify invoking on the trailing edge of the timeout.
 * @returns {Function} Returns the new debounced function.
 * @example
 *
 * // Avoid costly calculations while the window size is in flux.
 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
 *
 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
 * jQuery(element).on('click', _.debounce(sendMail, 300, {
 *   'leading': true,
 *   'trailing': false
 * }));
 *
 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
 * var source = new EventSource('/stream');
 * jQuery(source).on('message', debounced);
 *
 * // Cancel the trailing debounced invocation.
 * jQuery(window).on('popstate', debounced.cancel);
 */
function debounce(func, wait, options) {
  var lastArgs,
      lastThis,
      maxWait,
      result,
      timerId,
      lastCallTime,
      lastInvokeTime = 0,
      leading = false,
      maxing = false,
      trailing = true;

if (typeof func != 'function') {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  wait = toNumber(wait) || 0;
  if (isObject(options)) {
    leading = !!options.leading;
    maxing = 'maxWait' in options;
    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
    trailing = 'trailing' in options ? !!options.trailing : trailing;
  }

function invokeFunc(time) {
    var args = lastArgs,
        thisArg = lastThis;

lastArgs = lastThis = undefined;
    lastInvokeTime = time;
    result = func.apply(thisArg, args);
    return result;
  }

function leadingEdge(time) {
    // Reset any `maxWait` timer.
    lastInvokeTime = time;
    // Start the timer for the trailing edge.
    timerId = setTimeout(timerExpired, wait);
    // Invoke the leading edge.
    return leading ? invokeFunc(time) : result;
  }

function remainingWait(time) {
    var timeSinceLastCall = time - lastCallTime,
        timeSinceLastInvoke = time - lastInvokeTime,
        timeWaiting = wait - timeSinceLastCall;

return maxing
      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
      : timeWaiting;
  }

function shouldInvoke(time) {
    var timeSinceLastCall = time - lastCallTime,
        timeSinceLastInvoke = time - lastInvokeTime;

// Either this is the first call, activity has stopped and we're at the
    // trailing edge, the system time has gone backwards and we're treating
    // it as the trailing edge, or we've hit the `maxWait` limit.
    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
  }

function timerExpired() {
    var time = now();
    if (shouldInvoke(time)) {
      return trailingEdge(time);
    }
    // Restart the timer.
    timerId = setTimeout(timerExpired, remainingWait(time));
  }

function trailingEdge(time) {
    timerId = undefined;

// Only invoke if we have `lastArgs` which means `func` has been
    // debounced at least once.
    if (trailing && lastArgs) {
      return invokeFunc(time);
    }
    lastArgs = lastThis = undefined;
    return result;
  }

function cancel() {
    if (timerId !== undefined) {
      clearTimeout(timerId);
    }
    lastInvokeTime = 0;
    lastArgs = lastCallTime = lastThis = timerId = undefined;
  }

function flush() {
    return timerId === undefined ? result : trailingEdge(now());
  }

function debounced() {
    var time = now(),
        isInvoking = shouldInvoke(time);

lastArgs = arguments;
    lastThis = this;
    lastCallTime = time;

if (isInvoking) {
      if (timerId === undefined) {
        return leadingEdge(lastCallTime);
      }
      if (maxing) {
        // Handle invocations in a tight loop.
        clearTimeout(timerId);
        timerId = setTimeout(timerExpired, wait);
        return invokeFunc(lastCallTime);
      }
    }
    if (timerId === undefined) {
      timerId = setTimeout(timerExpired, wait);
    }
    return result;
  }
  debounced.cancel = cancel;
  debounced.flush = flush;
  return debounced;
}

module.exports = debounce;

/***/ }),
/* 292 */
/***/ (function(module, exports, __webpack_require__) {

var baseForOwn = __webpack_require__(430),
    castFunction = __webpack_require__(435);

/**
 * Iterates over own enumerable string keyed properties of an object and
 * invokes `iteratee` for each property. The iteratee is invoked with three
 * arguments: (value, key, object). Iteratee functions may exit iteration
 * early by explicitly returning `false`.
 *
 * @static
 * @memberOf _
 * @since 0.3.0
 * @category Object
 * @param {Object} object The object to iterate over.
 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
 * @returns {Object} Returns `object`.
 * @see _.forOwnRight
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.forOwn(new Foo, function(value, key) {
 *   console.log(key);
 * });
 * // => Logs 'a' then 'b' (iteration order is not guaranteed).
 */
function forOwn(object, iteratee) {
  return object && baseForOwn(object, castFunction(iteratee));
}

module.exports = forOwn;

/***/ }),
/* 293 */
/***/ (function(module, exports) {

/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;

/**
 * Checks if `value` is a valid array-like length.
 *
 * **Note:** This method is loosely based on
 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
 * @example
 *
 * _.isLength(3);
 * // => true
 *
 * _.isLength(Number.MIN_VALUE);
 * // => false
 *
 * _.isLength(Infinity);
 * // => false
 *
 * _.isLength('3');
 * // => false
 */
function isLength(value) {
  return typeof value == 'number' &&
    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
}

module.exports = isLength;

/***/ }),
/* 294 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsTypedArray = __webpack_require__(987),
    baseUnary = __webpack_require__(132),
    nodeUtil = __webpack_require__(289);

/* Node.js helper references. */
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

/**
 * Checks if `value` is classified as a typed array.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
 * @example
 *
 * _.isTypedArray(new Uint8Array);
 * // => true
 *
 * _.isTypedArray([]);
 * // => false
 */
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

module.exports = isTypedArray;

/***/ }),
/* 295 */
/***/ (function(module, exports) {

/**
 * This method returns `undefined`.
 *
 * @static
 * @memberOf _
 * @since 2.3.0
 * @category Util
 * @example
 *
 * _.times(2, _.noop);
 * // => [undefined, undefined]
 */
function noop() {
  // No operation performed.
}

module.exports = noop;

/***/ }),
/* 296 */
/***/ (function(module, exports, __webpack_require__) {

var debounce = __webpack_require__(291),
    isObject = __webpack_require__(46);

/** Error message constants. */
var FUNC_ERROR_TEXT = 'Expected a function';

/**
 * Creates a throttled function that only invokes `func` at most once per
 * every `wait` milliseconds. The throttled function comes with a `cancel`
 * method to cancel delayed `func` invocations and a `flush` method to
 * immediately invoke them. Provide `options` to indicate whether `func`
 * should be invoked on the leading and/or trailing edge of the `wait`
 * timeout. The `func` is invoked with the last arguments provided to the
 * throttled function. Subsequent calls to the throttled function return the
 * result of the last `func` invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is
 * invoked on the trailing edge of the timeout only if the throttled function
 * is invoked more than once during the `wait` timeout.
 *
 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
 *
 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
 * for details over the differences between `_.throttle` and `_.debounce`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to throttle.
 * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
 * @param {Object} [options={}] The options object.
 * @param {boolean} [options.leading=true]
 *  Specify invoking on the leading edge of the timeout.
 * @param {boolean} [options.trailing=true]
 *  Specify invoking on the trailing edge of the timeout.
 * @returns {Function} Returns the new throttled function.
 * @example
 *
 * // Avoid excessively updating the position while scrolling.
 * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
 *
 * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
 * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
 * jQuery(element).on('click', throttled);
 *
 * // Cancel the trailing throttled invocation.
 * jQuery(window).on('popstate', throttled.cancel);
 */
function throttle(func, wait, options) {
  var leading = true,
      trailing = true;

if (typeof func != 'function') {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  if (isObject(options)) {
    leading = 'leading' in options ? !!options.leading : leading;
    trailing = 'trailing' in options ? !!options.trailing : trailing;
  }
  return debounce(func, wait, {
    'leading': leading,
    'maxWait': wait,
    'trailing': trailing
  });
}

module.exports = throttle;

/***/ }),
/* 297 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

module.exports = ReactPropTypesSecret;

/***/ }),
/* 298 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {var now = __webpack_require__(1111)
  , root = typeof window === 'undefined' ? global : window
  , vendors = ['moz', 'webkit']
  , suffix = 'AnimationFrame'
  , raf = root['request' + suffix]
  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]

for(var i = 0; !raf && i < vendors.length; i++) {
  raf = root[vendors[i] + 'Request' + suffix]
  caf = root[vendors[i] + 'Cancel' + suffix]
      || root[vendors[i] + 'CancelRequest' + suffix]
}

// Some versions of FF have rAF but not cAF
if(!raf || !caf) {
  var last = 0
    , id = 0
    , queue = []
    , frameDuration = 1000 / 60

raf = function(callback) {
    if(queue.length === 0) {
      var _now = now()
        , next = Math.max(0, frameDuration - (_now - last))
      last = next + _now
      setTimeout(function() {
        var cp = queue.slice(0)
        // Clear queue here to prevent
        // callbacks from appending listeners
        // to the current frame's queue
        queue.length = 0
        for(var i = 0; i < cp.length; i++) {
          if(!cp[i].cancelled) {
            try{
              cp[i].callback(last)
            } catch(e) {
              setTimeout(function() { throw e }, 0)
            }
          }
        }
      }, Math.round(next))
    }
    queue.push({
      handle: ++id,
      callback: callback,
      cancelled: false
    })
    return id
  }

caf = function(handle) {
    for(var i = 0; i < queue.length; i++) {
      if(queue[i].handle === handle) {
        queue[i].cancelled = true
      }
    }
  }
}

module.exports = function(fn) {
  // Wrap in a new function to prevent
  // `cancel` potentially being assigned
  // to the native rAF function
  return raf.call(root, fn)
}
module.exports.cancel = function() {
  caf.apply(root, arguments)
}
module.exports.polyfill = function(object) {
  if (!object) {
    object = root;
  }
  object.requestAnimationFrame = raf
  object.cancelAnimationFrame = caf
}

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 299 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/* harmony export (immutable) */ __webpack_exports__["s"] = toTitle;
/* harmony export (immutable) */ __webpack_exports__["d"] = getValuePropValue;
/* harmony export (immutable) */ __webpack_exports__["f"] = getPropValue;
/* unused harmony export isMultiple */
/* harmony export (immutable) */ __webpack_exports__["c"] = isCombobox;
/* harmony export (immutable) */ __webpack_exports__["a"] = isMultipleOrTags;
/* harmony export (immutable) */ __webpack_exports__["g"] = isMultipleOrTagsOrCombobox;
/* harmony export (immutable) */ __webpack_exports__["h"] = isSingleMode;
/* harmony export (immutable) */ __webpack_exports__["l"] = toArray;
/* harmony export (immutable) */ __webpack_exports__["j"] = getMapKey;
/* harmony export (immutable) */ __webpack_exports__["m"] = preventDefaultEvent;
/* harmony export (immutable) */ __webpack_exports__["e"] = findIndexInValueBySingleValue;
/* harmony export (immutable) */ __webpack_exports__["k"] = getLabelFromPropsValue;
/* harmony export (immutable) */ __webpack_exports__["v"] = getSelectKeys;
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return UNSELECTABLE_STYLE; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return UNSELECTABLE_ATTRIBUTE; });
/* harmony export (immutable) */ __webpack_exports__["i"] = findFirstMenuItem;
/* harmony export (immutable) */ __webpack_exports__["b"] = includesSeparators;
/* harmony export (immutable) */ __webpack_exports__["p"] = splitBySeparators;
/* harmony export (immutable) */ __webpack_exports__["q"] = defaultFilterFn;
/* harmony export (immutable) */ __webpack_exports__["r"] = validateOptionValue;
/* harmony export (immutable) */ __webpack_exports__["t"] = saveRef;
/* harmony export (immutable) */ __webpack_exports__["u"] = generateUUID;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);

function toTitle(title) {
  if (typeof title === 'string') {
    return title;
  }

return '';
}
function getValuePropValue(child) {
  if (!child) {
    return null;
  }

var props = child.props;

if ('value' in props) {
    return props.value;
  }

if (child.key) {
    return child.key;
  }

if (child.type && child.type.isSelectOptGroup && props.label) {
    return props.label;
  }

throw new Error("Need at least a key or a value or a label (only for OptGroup) for ".concat(child));
}
function getPropValue(child, prop) {
  if (prop === 'value') {
    return getValuePropValue(child);
  }

return child.props[prop];
}
function isMultiple(props) {
  return props.multiple;
}
function isCombobox(props) {
  return props.combobox;
}
function isMultipleOrTags(props) {
  return props.multiple || props.tags;
}
function isMultipleOrTagsOrCombobox(props) {
  return isMultipleOrTags(props) || isCombobox(props);
}
function isSingleMode(props) {
  return !isMultipleOrTagsOrCombobox(props);
}
function toArray(value) {
  var ret = value;

if (value === undefined) {
    ret = [];
  } else if (!Array.isArray(value)) {
    ret = [value];
  }

return ret;
}
function getMapKey(value) {
  return "".concat(typeof value, "-").concat(value);
}
function preventDefaultEvent(e) {
  e.preventDefault();
}
function findIndexInValueBySingleValue(value, singleValue) {
  var index = -1;

if (value) {
    for (var i = 0; i < value.length; i++) {
      if (value[i] === singleValue) {
        index = i;
        break;
      }
    }
  }

return index;
}
function getLabelFromPropsValue(value, key) {
  var label;
  value = toArray(value);

if (value) {
    // tslint:disable-next-line:prefer-for-of
    for (var i = 0; i < value.length; i++) {
      if (value[i].key === key) {
        label = value[i].label;
        break;
      }
    }
  }

return label;
}
function getSelectKeys(menuItems, value) {
  if (value === null || value === undefined) {
    return [];
  }

var selectedKeys = [];
  __WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.forEach(menuItems, function (item) {
    var type = item.type;

if (type.isMenuItemGroup) {
      selectedKeys = selectedKeys.concat(getSelectKeys(item.props.children, value));
    } else {
      var itemValue = getValuePropValue(item);
      var itemKey = item.key;

if (findIndexInValueBySingleValue(value, itemValue) !== -1 && itemKey) {
        selectedKeys.push(itemKey);
      }
    }
  });
  return selectedKeys;
}
var UNSELECTABLE_STYLE = {
  userSelect: 'none',
  WebkitUserSelect: 'none'
};
var UNSELECTABLE_ATTRIBUTE = {
  unselectable: 'on'
};
function findFirstMenuItem(children) {
  // tslint:disable-next-line:prefer-for-of
  for (var i = 0; i < children.length; i++) {
    var child = children[i];

if (child.type.isMenuItemGroup) {
      var found = findFirstMenuItem(child.props.children);

if (found) {
        return found;
      }
    } else if (!child.props.disabled) {
      return child;
    }
  }

return null;
}
function includesSeparators(str, separators) {
  // tslint:disable-next-line:prefer-for-of
  for (var i = 0; i < separators.length; ++i) {
    if (str.lastIndexOf(separators[i]) > 0) {
      return true;
    }
  }

return false;
}
function splitBySeparators(str, separators) {
  var reg = new RegExp("[".concat(separators.join(), "]"));
  return str.split(reg).filter(function (token) {
    return token;
  });
}
function defaultFilterFn(input, child) {
  if (child.props.disabled) {
    return false;
  }

var value = toArray(getPropValue(child, this.props.optionFilterProp)).join('');
  return value.toLowerCase().indexOf(input.toLowerCase()) > -1;
}
function validateOptionValue(value, props) {
  if (isSingleMode(props) || isMultiple(props)) {
    return;
  }

if (typeof value !== 'string') {
    throw new Error("Invalid `value` of type `".concat(typeof value, "` supplied to Option, ") + "expected `string` when `tags/combobox` is `true`.");
  }
}
function saveRef(instance, name) {
  return function (node) {
    instance[name] = node;
  };
}
function generateUUID() {
  if (process.env.NODE_ENV === 'test') {
    return 'test-uuid';
  }

var d = new Date().getTime();
  var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
    // tslint:disable-next-line:no-bitwise
    var r = (d + Math.random() * 16) % 16 | 0;
    d = Math.floor(d / 16); // tslint:disable-next-line:no-bitwise

return (c === 'x' ? r : r & 0x7 | 0x8).toString(16);
  });
  return uuid;
}
/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(1)))

/***/ }),
/* 300 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/* harmony export (immutable) */ __webpack_exports__["a"] = isDev;
/* harmony export (immutable) */ __webpack_exports__["h"] = isEventFromHandle;
/* harmony export (immutable) */ __webpack_exports__["b"] = isValueOutOfRange;
/* harmony export (immutable) */ __webpack_exports__["j"] = isNotTouchEvent;
/* unused harmony export getClosestPoint */
/* unused harmony export getPrecision */
/* harmony export (immutable) */ __webpack_exports__["g"] = getMousePosition;
/* harmony export (immutable) */ __webpack_exports__["k"] = getTouchPosition;
/* harmony export (immutable) */ __webpack_exports__["i"] = getHandleCenterPosition;
/* harmony export (immutable) */ __webpack_exports__["e"] = ensureValueInRange;
/* harmony export (immutable) */ __webpack_exports__["f"] = ensureValuePrecision;
/* harmony export (immutable) */ __webpack_exports__["c"] = pauseEvent;
/* unused harmony export calculateNextValue */
/* harmony export (immutable) */ __webpack_exports__["d"] = getKeyboardValueMutator;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray__ = __webpack_require__(160);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__ = __webpack_require__(87);

function isDev() {
  return process.env.NODE_ENV !== 'production';
}

function isValueOutOfRange(value, _ref) {
  var min = _ref.min,
      max = _ref.max;

return value < min || value > max;
}

function isNotTouchEvent(e) {
  return e.touches.length > 1 || e.type.toLowerCase() === 'touchend' && e.touches.length > 0;
}

function getClosestPoint(val, _ref2) {
  var marks = _ref2.marks,
      step = _ref2.step,
      min = _ref2.min,
      max = _ref2.max;

var points = Object.keys(marks).map(parseFloat);
  if (step !== null) {
    var maxSteps = Math.floor((max - min) / step);
    var steps = Math.min((val - min) / step, maxSteps);
    var closestStep = Math.round(steps) * step + min;
    points.push(closestStep);
  }
  var diffs = points.map(function (point) {
    return Math.abs(val - point);
  });
  return points[diffs.indexOf(Math.min.apply(Math, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_toConsumableArray___default()(diffs)))];
}

function getPrecision(step) {
  var stepString = step.toString();
  var precision = 0;
  if (stepString.indexOf('.') >= 0) {
    precision = stepString.length - stepString.indexOf('.') - 1;
  }
  return precision;
}

function getMousePosition(vertical, e) {
  return vertical ? e.clientY : e.pageX;
}

function getTouchPosition(vertical, e) {
  return vertical ? e.touches[0].clientY : e.touches[0].pageX;
}

function getHandleCenterPosition(vertical, handle) {
  var coords = handle.getBoundingClientRect();
  return vertical ? coords.top + coords.height * 0.5 : window.pageXOffset + coords.left + coords.width * 0.5;
}

function ensureValueInRange(val, _ref3) {
  var max = _ref3.max,
      min = _ref3.min;

if (val <= min) {
    return min;
  }
  if (val >= max) {
    return max;
  }
  return val;
}

function ensureValuePrecision(val, props) {
  var step = props.step;

var closestPoint = isFinite(getClosestPoint(val, props)) ? getClosestPoint(val, props) : 0; // eslint-disable-line
  return step === null ? closestPoint : parseFloat(closestPoint.toFixed(getPrecision(step)));
}

function pauseEvent(e) {
  e.stopPropagation();
  e.preventDefault();
}

var indexToGet = operations[func](Object.keys(props.marks).indexOf(JSON.stringify(value)), 1);
  var keyToGet = Object.keys(props.marks)[indexToGet];

if (props.step) {
    return operations[func](value, props.step);
  } else if (!!Object.keys(props.marks).length && !!props.marks[keyToGet]) {
    return props.marks[keyToGet];
  }
  return value;
}

function getKeyboardValueMutator(e) {
  switch (e.keyCode) {
    case __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].UP:
    case __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].RIGHT:
      return function (value, props) {
        return calculateNextValue('increase', value, props);
      };

case __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].DOWN:
    case __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].LEFT:
      return function (value, props) {
        return calculateNextValue('decrease', value, props);
      };

case __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].END:
      return function (value, props) {
        return props.max;
      };
    case __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].HOME:
      return function (value, props) {
        return props.min;
      };
    case __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].PAGE_UP:
      return function (value, props) {
        return value + props.step * 2;
      };
    case __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].PAGE_DOWN:
      return function (value, props) {
        return value - props.step * 2;
      };

default:
      return undefined;
  }
}
/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(1)))

/***/ }),
/* 301 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react_lifecycles_compat__ = __webpack_require__(61);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_util_es_Dom_contains__ = __webpack_require__(302);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rc_util_es_Dom_addEventListener__ = __webpack_require__(141);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_rc_util_es_ContainerRender__ = __webpack_require__(481);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11_rc_util_es_Portal__ = __webpack_require__(482);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_12_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__utils__ = __webpack_require__(479);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__Popup__ = __webpack_require__(1162);

function noop() {}

function returnEmptyString() {
  return '';
}

function returnDocument() {
  return window.document;
}

var ALL_HANDLERS = ['onClick', 'onMouseDown', 'onTouchStart', 'onMouseEnter', 'onMouseLeave', 'onFocus', 'onBlur', 'onContextMenu'];

var IS_REACT_16 = !!__WEBPACK_IMPORTED_MODULE_6_react_dom__["createPortal"];

var contextTypes = {
  rcTrigger: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.shape({
    onPopupMouseDown: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func
  })
};

var Trigger = function (_React$Component) {
  __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(Trigger, _React$Component);

function Trigger(props) {
    __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, Trigger);

var _this = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, _React$Component.call(this, props));

_initialiseProps.call(_this);

var popupVisible = void 0;
    if ('popupVisible' in props) {
      popupVisible = !!props.popupVisible;
    } else {
      popupVisible = !!props.defaultPopupVisible;
    }

_this.state = {
      prevPopupVisible: popupVisible,
      popupVisible: popupVisible
    };

ALL_HANDLERS.forEach(function (h) {
      _this['fire' + h] = function (e) {
        _this.fireEvents(h, e);
      };
    });
    return _this;
  }

Trigger.prototype.getChildContext = function getChildContext() {
    return {
      rcTrigger: {
        onPopupMouseDown: this.onPopupMouseDown
      }
    };
  };

Trigger.prototype.componentDidMount = function componentDidMount() {
    this.componentDidUpdate({}, {
      popupVisible: this.state.popupVisible
    });
  };

Trigger.prototype.componentDidUpdate = function componentDidUpdate(_, prevState) {
    var props = this.props;
    var state = this.state;
    var triggerAfterPopupVisibleChange = function triggerAfterPopupVisibleChange() {
      if (prevState.popupVisible !== state.popupVisible) {
        props.afterPopupVisibleChange(state.popupVisible);
      }
    };
    if (!IS_REACT_16) {
      this.renderComponent(null, triggerAfterPopupVisibleChange);
    }

// We must listen to `mousedown` or `touchstart`, edge case:
    // https://github.com/ant-design/ant-design/issues/5804
    // https://github.com/react-component/calendar/issues/250
    // https://github.com/react-component/trigger/issues/50
    if (state.popupVisible) {
      var currentDocument = void 0;
      if (!this.clickOutsideHandler && (this.isClickToHide() || this.isContextMenuToShow())) {
        currentDocument = props.getDocument();
        this.clickOutsideHandler = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9_rc_util_es_Dom_addEventListener__["a" /* default */])(currentDocument, 'mousedown', this.onDocumentClick);
      }
      // always hide on mobile
      if (!this.touchOutsideHandler) {
        currentDocument = currentDocument || props.getDocument();
        this.touchOutsideHandler = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9_rc_util_es_Dom_addEventListener__["a" /* default */])(currentDocument, 'touchstart', this.onDocumentClick);
      }
      // close popup when trigger type contains 'onContextMenu' and document is scrolling.
      if (!this.contextMenuOutsideHandler1 && this.isContextMenuToShow()) {
        currentDocument = currentDocument || props.getDocument();
        this.contextMenuOutsideHandler1 = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9_rc_util_es_Dom_addEventListener__["a" /* default */])(currentDocument, 'scroll', this.onContextMenuClose);
      }
      // close popup when trigger type contains 'onContextMenu' and window is blur.
      if (!this.contextMenuOutsideHandler2 && this.isContextMenuToShow()) {
        this.contextMenuOutsideHandler2 = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9_rc_util_es_Dom_addEventListener__["a" /* default */])(window, 'blur', this.onContextMenuClose);
      }
      return;
    }

this.clearOutsideHandler();
  };

Trigger.prototype.componentWillUnmount = function componentWillUnmount() {
    this.clearDelayTimer();
    this.clearOutsideHandler();
    clearTimeout(this.mouseDownTimeout);
  };

Trigger.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {
    var popupVisible = _ref.popupVisible;

var newState = {};

if (popupVisible !== undefined && prevState.popupVisible !== popupVisible) {
      newState.popupVisible = popupVisible;
      newState.prevPopupVisible = prevState.popupVisible;
    }

return newState;
  };

Trigger.prototype.getPopupDomNode = function getPopupDomNode() {
    // for test
    if (this._component && this._component.getPopupDomNode) {
      return this._component.getPopupDomNode();
    }
    return null;
  };

Trigger.prototype.getPopupAlign = function getPopupAlign() {
    var props = this.props;
    var popupPlacement = props.popupPlacement,
        popupAlign = props.popupAlign,
        builtinPlacements = props.builtinPlacements;

if (popupPlacement && builtinPlacements) {
      return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__utils__["a" /* getAlignFromPlacement */])(builtinPlacements, popupPlacement, popupAlign);
    }
    return popupAlign;
  };

/**
   * @param popupVisible    Show or not the popup element
   * @param event           SyntheticEvent, used for `pointAlign`
   */
  Trigger.prototype.setPopupVisible = function setPopupVisible(popupVisible, event) {
    var alignPoint = this.props.alignPoint;
    var prevPopupVisible = this.state.popupVisible;

this.clearDelayTimer();

if (prevPopupVisible !== popupVisible) {
      if (!('popupVisible' in this.props)) {
        this.setState({ popupVisible: popupVisible, prevPopupVisible: prevPopupVisible });
      }
      this.props.onPopupVisibleChange(popupVisible);
    }

// Always record the point position since mouseEnterDelay will delay the show
    if (alignPoint && event) {
      this.setPoint(event);
    }
  };

Trigger.prototype.delaySetPopupVisible = function delaySetPopupVisible(visible, delayS, event) {
    var _this2 = this;

Trigger.prototype.clearDelayTimer = function clearDelayTimer() {
    if (this.delayTimer) {
      clearTimeout(this.delayTimer);
      this.delayTimer = null;
    }
  };

Trigger.prototype.clearOutsideHandler = function clearOutsideHandler() {
    if (this.clickOutsideHandler) {
      this.clickOutsideHandler.remove();
      this.clickOutsideHandler = null;
    }

if (this.contextMenuOutsideHandler1) {
      this.contextMenuOutsideHandler1.remove();
      this.contextMenuOutsideHandler1 = null;
    }

if (this.contextMenuOutsideHandler2) {
      this.contextMenuOutsideHandler2.remove();
      this.contextMenuOutsideHandler2 = null;
    }

if (this.touchOutsideHandler) {
      this.touchOutsideHandler.remove();
      this.touchOutsideHandler = null;
    }
  };

Trigger.prototype.createTwoChains = function createTwoChains(event) {
    var childPros = this.props.children.props;
    var props = this.props;
    if (childPros[event] && props[event]) {
      return this['fire' + event];
    }
    return childPros[event] || props[event];
  };

Trigger.prototype.isClickToShow = function isClickToShow() {
    var _props = this.props,
        action = _props.action,
        showAction = _props.showAction;

return action.indexOf('click') !== -1 || showAction.indexOf('click') !== -1;
  };

Trigger.prototype.isContextMenuToShow = function isContextMenuToShow() {
    var _props2 = this.props,
        action = _props2.action,
        showAction = _props2.showAction;

return action.indexOf('contextMenu') !== -1 || showAction.indexOf('contextMenu') !== -1;
  };

Trigger.prototype.isClickToHide = function isClickToHide() {
    var _props3 = this.props,
        action = _props3.action,
        hideAction = _props3.hideAction;

return action.indexOf('click') !== -1 || hideAction.indexOf('click') !== -1;
  };

Trigger.prototype.isMouseEnterToShow = function isMouseEnterToShow() {
    var _props4 = this.props,
        action = _props4.action,
        showAction = _props4.showAction;

return action.indexOf('hover') !== -1 || showAction.indexOf('mouseEnter') !== -1;
  };

Trigger.prototype.isMouseLeaveToHide = function isMouseLeaveToHide() {
    var _props5 = this.props,
        action = _props5.action,
        hideAction = _props5.hideAction;

return action.indexOf('hover') !== -1 || hideAction.indexOf('mouseLeave') !== -1;
  };

Trigger.prototype.isFocusToShow = function isFocusToShow() {
    var _props6 = this.props,
        action = _props6.action,
        showAction = _props6.showAction;

return action.indexOf('focus') !== -1 || showAction.indexOf('focus') !== -1;
  };

Trigger.prototype.isBlurToHide = function isBlurToHide() {
    var _props7 = this.props,
        action = _props7.action,
        hideAction = _props7.hideAction;

return action.indexOf('focus') !== -1 || hideAction.indexOf('blur') !== -1;
  };

Trigger.prototype.forcePopupAlign = function forcePopupAlign() {
    if (this.state.popupVisible && this._component && this._component.alignInstance) {
      this._component.alignInstance.forceAlign();
    }
  };

Trigger.prototype.fireEvents = function fireEvents(type, e) {
    var childCallback = this.props.children.props[type];
    if (childCallback) {
      childCallback(e);
    }
    var callback = this.props[type];
    if (callback) {
      callback(e);
    }
  };

Trigger.prototype.close = function close() {
    this.setPopupVisible(false);
  };

Trigger.prototype.render = function render() {
    var _this3 = this;

var popupVisible = this.state.popupVisible;
    var _props8 = this.props,
        children = _props8.children,
        forceRender = _props8.forceRender,
        alignPoint = _props8.alignPoint,
        className = _props8.className;

var child = __WEBPACK_IMPORTED_MODULE_4_react___default.a.Children.only(children);
    var newChildProps = { key: 'trigger' };

if (this.isContextMenuToShow()) {
      newChildProps.onContextMenu = this.onContextMenu;
    } else {
      newChildProps.onContextMenu = this.createTwoChains('onContextMenu');
    }

if (this.isClickToHide() || this.isClickToShow()) {
      newChildProps.onClick = this.onClick;
      newChildProps.onMouseDown = this.onMouseDown;
      newChildProps.onTouchStart = this.onTouchStart;
    } else {
      newChildProps.onClick = this.createTwoChains('onClick');
      newChildProps.onMouseDown = this.createTwoChains('onMouseDown');
      newChildProps.onTouchStart = this.createTwoChains('onTouchStart');
    }
    if (this.isMouseEnterToShow()) {
      newChildProps.onMouseEnter = this.onMouseEnter;
      if (alignPoint) {
        newChildProps.onMouseMove = this.onMouseMove;
      }
    } else {
      newChildProps.onMouseEnter = this.createTwoChains('onMouseEnter');
    }
    if (this.isMouseLeaveToHide()) {
      newChildProps.onMouseLeave = this.onMouseLeave;
    } else {
      newChildProps.onMouseLeave = this.createTwoChains('onMouseLeave');
    }
    if (this.isFocusToShow() || this.isBlurToHide()) {
      newChildProps.onFocus = this.onFocus;
      newChildProps.onBlur = this.onBlur;
    } else {
      newChildProps.onFocus = this.createTwoChains('onFocus');
      newChildProps.onBlur = this.createTwoChains('onBlur');
    }

var childrenClassName = __WEBPACK_IMPORTED_MODULE_12_classnames___default()(child && child.props && child.props.className, className);
    if (childrenClassName) {
      newChildProps.className = childrenClassName;
    }
    var trigger = __WEBPACK_IMPORTED_MODULE_4_react___default.a.cloneElement(child, newChildProps);

if (!IS_REACT_16) {
      return __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
        __WEBPACK_IMPORTED_MODULE_10_rc_util_es_ContainerRender__["a" /* default */],
        {
          parent: this,
          visible: popupVisible,
          autoMount: false,
          forceRender: forceRender,
          getComponent: this.getComponent,
          getContainer: this.getContainer
        },
        function (_ref2) {
          var renderComponent = _ref2.renderComponent;

_this3.renderComponent = renderComponent;
          return trigger;
        }
      );
    }

var portal = void 0;
    // prevent unmounting after it's rendered
    if (popupVisible || this._component || forceRender) {
      portal = __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
        __WEBPACK_IMPORTED_MODULE_11_rc_util_es_Portal__["a" /* default */],
        { key: 'portal', getContainer: this.getContainer, didUpdate: this.handlePortalUpdate },
        this.getComponent()
      );
    }

return [trigger, portal];
  };

return Trigger;
}(__WEBPACK_IMPORTED_MODULE_4_react___default.a.Component);

Trigger.propTypes = {
  children: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.any,
  action: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string)]),
  showAction: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.any,
  hideAction: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.any,
  getPopupClassNameFromAlign: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.any,
  onPopupVisibleChange: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  afterPopupVisibleChange: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  popup: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.node, __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func]).isRequired,
  popupStyle: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.object,
  prefixCls: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  popupClassName: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  className: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  popupPlacement: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  builtinPlacements: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.object,
  popupTransitionName: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.object]),
  popupAnimation: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.any,
  mouseEnterDelay: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
  mouseLeaveDelay: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
  zIndex: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
  focusDelay: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
  blurDelay: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
  getPopupContainer: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  getDocument: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  forceRender: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  destroyPopupOnHide: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  mask: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  maskClosable: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  onPopupAlign: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  popupAlign: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.object,
  popupVisible: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  defaultPopupVisible: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  maskTransitionName: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.object]),
  maskAnimation: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  stretch: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  alignPoint: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool // Maybe we can support user pass position in the future
};
Trigger.contextTypes = contextTypes;
Trigger.childContextTypes = contextTypes;
Trigger.defaultProps = {
  prefixCls: 'rc-trigger-popup',
  getPopupClassNameFromAlign: returnEmptyString,
  getDocument: returnDocument,
  onPopupVisibleChange: noop,
  afterPopupVisibleChange: noop,
  onPopupAlign: noop,
  popupClassName: '',
  mouseEnterDelay: 0,
  mouseLeaveDelay: 0.1,
  focusDelay: 0,
  blurDelay: 0.15,
  popupStyle: {},
  destroyPopupOnHide: false,
  popupAlign: {},
  defaultPopupVisible: false,
  mask: false,
  maskClosable: true,
  action: [],
  showAction: [],
  hideAction: []
};

var _initialiseProps = function _initialiseProps() {
  var _this4 = this;

this.onMouseEnter = function (e) {
    var mouseEnterDelay = _this4.props.mouseEnterDelay;

_this4.fireEvents('onMouseEnter', e);
    _this4.delaySetPopupVisible(true, mouseEnterDelay, mouseEnterDelay ? null : e);
  };

this.onMouseMove = function (e) {
    _this4.fireEvents('onMouseMove', e);
    _this4.setPoint(e);
  };

this.onMouseLeave = function (e) {
    _this4.fireEvents('onMouseLeave', e);
    _this4.delaySetPopupVisible(false, _this4.props.mouseLeaveDelay);
  };

this.onPopupMouseEnter = function () {
    _this4.clearDelayTimer();
  };

this.onPopupMouseLeave = function (e) {
    // https://github.com/react-component/trigger/pull/13
    // react bug?
    if (e.relatedTarget && !e.relatedTarget.setTimeout && _this4._component && _this4._component.getPopupDomNode && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8_rc_util_es_Dom_contains__["a" /* default */])(_this4._component.getPopupDomNode(), e.relatedTarget)) {
      return;
    }
    _this4.delaySetPopupVisible(false, _this4.props.mouseLeaveDelay);
  };

this.onFocus = function (e) {
    _this4.fireEvents('onFocus', e);
    // incase focusin and focusout
    _this4.clearDelayTimer();
    if (_this4.isFocusToShow()) {
      _this4.focusTime = Date.now();
      _this4.delaySetPopupVisible(true, _this4.props.focusDelay);
    }
  };

this.onMouseDown = function (e) {
    _this4.fireEvents('onMouseDown', e);
    _this4.preClickTime = Date.now();
  };

this.onTouchStart = function (e) {
    _this4.fireEvents('onTouchStart', e);
    _this4.preTouchTime = Date.now();
  };

this.onBlur = function (e) {
    _this4.fireEvents('onBlur', e);
    _this4.clearDelayTimer();
    if (_this4.isBlurToHide()) {
      _this4.delaySetPopupVisible(false, _this4.props.blurDelay);
    }
  };

this.onContextMenu = function (e) {
    e.preventDefault();
    _this4.fireEvents('onContextMenu', e);
    _this4.setPopupVisible(true, e);
  };

this.onContextMenuClose = function () {
    if (_this4.isContextMenuToShow()) {
      _this4.close();
    }
  };

this.onClick = function (event) {
    _this4.fireEvents('onClick', event);
    // focus will trigger click
    if (_this4.focusTime) {
      var preTime = void 0;
      if (_this4.preClickTime && _this4.preTouchTime) {
        preTime = Math.min(_this4.preClickTime, _this4.preTouchTime);
      } else if (_this4.preClickTime) {
        preTime = _this4.preClickTime;
      } else if (_this4.preTouchTime) {
        preTime = _this4.preTouchTime;
      }
      if (Math.abs(preTime - _this4.focusTime) < 20) {
        return;
      }
      _this4.focusTime = 0;
    }
    _this4.preClickTime = 0;
    _this4.preTouchTime = 0;

// Only prevent default when all the action is click.
    // https://github.com/ant-design/ant-design/issues/17043
    // https://github.com/ant-design/ant-design/issues/17291
    if (_this4.isClickToShow() && (_this4.isClickToHide() || _this4.isBlurToHide()) && event && event.preventDefault) {
      event.preventDefault();
    }
    var nextVisible = !_this4.state.popupVisible;
    if (_this4.isClickToHide() && !nextVisible || nextVisible && _this4.isClickToShow()) {
      _this4.setPopupVisible(!_this4.state.popupVisible, event);
    }
  };

this.onPopupMouseDown = function () {
    var _context$rcTrigger = _this4.context.rcTrigger,
        rcTrigger = _context$rcTrigger === undefined ? {} : _context$rcTrigger;

_this4.hasPopupMouseDown = true;

clearTimeout(_this4.mouseDownTimeout);
    _this4.mouseDownTimeout = setTimeout(function () {
      _this4.hasPopupMouseDown = false;
    }, 0);

if (rcTrigger.onPopupMouseDown) {
      rcTrigger.onPopupMouseDown.apply(rcTrigger, arguments);
    }
  };

this.onDocumentClick = function (event) {
    if (_this4.props.mask && !_this4.props.maskClosable) {
      return;
    }

var target = event.target;
    var root = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6_react_dom__["findDOMNode"])(_this4);
    if (!__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8_rc_util_es_Dom_contains__["a" /* default */])(root, target) && !_this4.hasPopupMouseDown) {
      _this4.close();
    }
  };

this.getRootDomNode = function () {
    return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6_react_dom__["findDOMNode"])(_this4);
  };

this.getPopupClassNameFromAlign = function (align) {
    var className = [];
    var _props9 = _this4.props,
        popupPlacement = _props9.popupPlacement,
        builtinPlacements = _props9.builtinPlacements,
        prefixCls = _props9.prefixCls,
        alignPoint = _props9.alignPoint,
        getPopupClassNameFromAlign = _props9.getPopupClassNameFromAlign;

if (popupPlacement && builtinPlacements) {
      className.push(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__utils__["b" /* getAlignPopupClassName */])(builtinPlacements, prefixCls, align, alignPoint));
    }
    if (getPopupClassNameFromAlign) {
      className.push(getPopupClassNameFromAlign(align));
    }
    return className.join(' ');
  };

this.getComponent = function () {
    var _props10 = _this4.props,
        prefixCls = _props10.prefixCls,
        destroyPopupOnHide = _props10.destroyPopupOnHide,
        popupClassName = _props10.popupClassName,
        action = _props10.action,
        onPopupAlign = _props10.onPopupAlign,
        popupAnimation = _props10.popupAnimation,
        popupTransitionName = _props10.popupTransitionName,
        popupStyle = _props10.popupStyle,
        mask = _props10.mask,
        maskAnimation = _props10.maskAnimation,
        maskTransitionName = _props10.maskTransitionName,
        zIndex = _props10.zIndex,
        popup = _props10.popup,
        stretch = _props10.stretch,
        alignPoint = _props10.alignPoint;
    var _state = _this4.state,
        popupVisible = _state.popupVisible,
        point = _state.point;

var align = _this4.getPopupAlign();

mouseProps.onMouseDown = _this4.onPopupMouseDown;
    mouseProps.onTouchStart = _this4.onPopupMouseDown;

return __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
      __WEBPACK_IMPORTED_MODULE_14__Popup__["a" /* default */],
      __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({
        prefixCls: prefixCls,
        destroyPopupOnHide: destroyPopupOnHide,
        visible: popupVisible,
        point: alignPoint && point,
        className: popupClassName,
        action: action,
        align: align,
        onAlign: onPopupAlign,
        animation: popupAnimation,
        getClassNameFromAlign: _this4.getPopupClassNameFromAlign
      }, mouseProps, {
        stretch: stretch,
        getRootDomNode: _this4.getRootDomNode,
        style: popupStyle,
        mask: mask,
        zIndex: zIndex,
        transitionName: popupTransitionName,
        maskAnimation: maskAnimation,
        maskTransitionName: maskTransitionName,
        ref: _this4.savePopup
      }),
      typeof popup === 'function' ? popup() : popup
    );
  };

this.getContainer = function () {
    var props = _this4.props;

var popupContainer = document.createElement('div');
    // Make sure default popup container will never cause scrollbar appearing
    // https://github.com/react-component/trigger/issues/41
    popupContainer.style.position = 'absolute';
    popupContainer.style.top = '0';
    popupContainer.style.left = '0';
    popupContainer.style.width = '100%';
    var mountNode = props.getPopupContainer ? props.getPopupContainer(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6_react_dom__["findDOMNode"])(_this4)) : props.getDocument().body;
    mountNode.appendChild(popupContainer);
    return popupContainer;
  };

this.setPoint = function (point) {
    var alignPoint = _this4.props.alignPoint;

if (!alignPoint || !point) return;

_this4.setState({
      point: {
        pageX: point.pageX,
        pageY: point.pageY
      }
    });
  };

this.handlePortalUpdate = function () {
    if (_this4.state.prevPopupVisible !== _this4.state.popupVisible) {
      _this4.props.afterPopupVisibleChange(_this4.state.popupVisible);
    }
  };

this.savePopup = function (node) {
    _this4._component = node;
  };
};

__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7_react_lifecycles_compat__["polyfill"])(Trigger);

/* harmony default export */ __webpack_exports__["a"] = (Trigger);

/***/ }),
/* 302 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = contains;
function contains(root, n) {
  var node = n;

while (node) {
    if (node === root) {
      return true;
    }

node = node.parentNode;
  }

return false;
}

/***/ }),
/* 303 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
var FILE = '__NATIVE_FILE__';
exports.FILE = FILE;
var URL = '__NATIVE_URL__';
exports.URL = URL;
var TEXT = '__NATIVE_TEXT__';
exports.TEXT = TEXT;

/***/ }),
/* 304 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = createHTML5Backend;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _HTML5Backend = __webpack_require__(1217);

var _HTML5Backend2 = _interopRequireDefault(_HTML5Backend);

var _getEmptyImage = __webpack_require__(1221);

var _getEmptyImage2 = _interopRequireDefault(_getEmptyImage);

var _NativeTypes = __webpack_require__(303);

var NativeTypes = _interopRequireWildcard(_NativeTypes);

exports.NativeTypes = NativeTypes;
exports.getEmptyImage = _getEmptyImage2['default'];

function createHTML5Backend(manager) {
  return new _HTML5Backend2['default'](manager);
}

/***/ }),
/* 305 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports["default"] = shallowEqual;

function shallowEqual(objA, objB) {
  if (objA === objB) {
    return true;
  }

var keysA = Object.keys(objA);
  var keysB = Object.keys(objB);

if (keysA.length !== keysB.length) {
    return false;
  }

// Test for A's keys different from B.
  var hasOwn = Object.prototype.hasOwnProperty;
  for (var i = 0; i < keysA.length; i++) {
    if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
      return false;
    }

var valA = objA[keysA[i]];
    var valB = objB[keysA[i]];

if (valA !== valB) {
      return false;
    }
  }

return true;
}

module.exports = exports["default"];

/***/ }),
/* 306 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

if (process.env.NODE_ENV === 'production') {
  module.exports = __webpack_require__(1242);
} else {
  module.exports = __webpack_require__(1241);
}

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 307 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.loopAsync = loopAsync;
exports.mapAsync = mapAsync;
function loopAsync(turns, work, callback) {
  var currentTurn = 0,
      isDone = false;
  var sync = false,
      hasNext = false,
      doneArgs = void 0;

function done() {
    isDone = true;
    if (sync) {
      // Iterate instead of recursing if possible.
      doneArgs = [].concat(Array.prototype.slice.call(arguments));
      return;
    }

callback.apply(this, arguments);
  }

function next() {
    if (isDone) {
      return;
    }

hasNext = true;
    if (sync) {
      // Iterate instead of recursing if possible.
      return;
    }

sync = true;

while (!isDone && currentTurn < turns && hasNext) {
      hasNext = false;
      work.call(this, currentTurn++, next, done);
    }

sync = false;

if (isDone) {
      // This means the loop finished synchronously.
      callback.apply(this, doneArgs);
      return;
    }

if (currentTurn >= turns && hasNext) {
      isDone = true;
      callback();
    }
  }

next();
}

function mapAsync(array, work, callback) {
  var length = array.length;
  var values = [];

if (length === 0) return callback(null, values);

var isDone = false,
      doneCount = 0;

function done(index, error, value) {
    if (isDone) return;

if (error) {
      isDone = true;
      callback(error);
    } else {
      values[index] = value;

isDone = ++doneCount === length;

if (isDone) callback(null, values);
    }
  }

array.forEach(function (item, index) {
    work(item, index, function (error, value) {
      done(index, error, value);
    });
  });
}

/***/ }),
/* 308 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.router = exports.routes = exports.route = exports.components = exports.component = exports.location = exports.history = exports.falsy = exports.locationShape = exports.routerShape = undefined;

var _react = __webpack_require__(0);

var _deprecateObjectProperties = __webpack_require__(188);

var _deprecateObjectProperties2 = _interopRequireDefault(_deprecateObjectProperties);

var _InternalPropTypes = __webpack_require__(88);

var InternalPropTypes = _interopRequireWildcard(_InternalPropTypes);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var func = _react.PropTypes.func;
var object = _react.PropTypes.object;
var shape = _react.PropTypes.shape;
var string = _react.PropTypes.string;
var routerShape = exports.routerShape = shape({
  push: func.isRequired,
  replace: func.isRequired,
  go: func.isRequired,
  goBack: func.isRequired,
  goForward: func.isRequired,
  setRouteLeaveHook: func.isRequired,
  isActive: func.isRequired
});

var locationShape = exports.locationShape = shape({
  pathname: string.isRequired,
  search: string.isRequired,
  state: object,
  action: string.isRequired,
  key: string
});

// Deprecated stuff below:

var falsy = exports.falsy = InternalPropTypes.falsy;
var history = exports.history = InternalPropTypes.history;
var location = exports.location = locationShape;
var component = exports.component = InternalPropTypes.component;
var components = exports.components = InternalPropTypes.components;
var route = exports.route = InternalPropTypes.route;
var routes = exports.routes = InternalPropTypes.routes;
var router = exports.router = routerShape;

if (process.env.NODE_ENV !== 'production') {
  (function () {
    var deprecatePropType = function deprecatePropType(propType, message) {
      return function () {
        process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, message) : void 0;
        return propType.apply(undefined, arguments);
      };
    };

var deprecateInternalPropType = function deprecateInternalPropType(propType) {
      return deprecatePropType(propType, 'This prop type is not intended for external use, and was previously exported by mistake. These internal prop types are deprecated for external use, and will be removed in a later version.');
    };

var deprecateRenamedPropType = function deprecateRenamedPropType(propType, name) {
      return deprecatePropType(propType, 'The `' + name + '` prop type is now exported as `' + name + 'Shape` to avoid name conflicts. This export is deprecated and will be removed in a later version.');
    };

exports.falsy = falsy = deprecateInternalPropType(falsy);
    exports.history = history = deprecateInternalPropType(history);
    exports.component = component = deprecateInternalPropType(component);
    exports.components = components = deprecateInternalPropType(components);
    exports.route = route = deprecateInternalPropType(route);
    exports.routes = routes = deprecateInternalPropType(routes);

exports.location = location = deprecateRenamedPropType(location, 'location');
    exports.router = router = deprecateRenamedPropType(router, 'router');
  })();
}

var defaultExport = {
  falsy: falsy,
  history: history,
  location: location,
  component: component,
  components: components,
  route: route,
  // For some reason, routes was never here.
  router: router
};

if (process.env.NODE_ENV !== 'production') {
  defaultExport = (0, _deprecateObjectProperties2.default)(defaultExport, 'The default export from `react-router/lib/PropTypes` is deprecated. Please use the named exports instead.');
}

exports.default = defaultExport;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 309 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

exports.default = createTransitionManager;

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

var _computeChangedRoutes2 = __webpack_require__(1256);

var _computeChangedRoutes3 = _interopRequireDefault(_computeChangedRoutes2);

var _TransitionUtils = __webpack_require__(1253);

var _isActive2 = __webpack_require__(1260);

var _isActive3 = _interopRequireDefault(_isActive2);

var _getComponents = __webpack_require__(1257);

var _getComponents2 = _interopRequireDefault(_getComponents);

var _matchRoutes = __webpack_require__(1262);

var _matchRoutes2 = _interopRequireDefault(_matchRoutes);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function hasAnyProperties(object) {
  for (var p in object) {
    if (Object.prototype.hasOwnProperty.call(object, p)) return true;
  }return false;
}

function createTransitionManager(history, routes) {
  var state = {};

// Signature should be (location, indexOnly), but needs to support (path,
  // query, indexOnly)
  function isActive(location) {
    var indexOnlyOrDeprecatedQuery = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
    var deprecatedIndexOnly = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];

return (0, _isActive3.default)(location, indexOnly, state.location, state.routes, state.params);
  }

var partialNextState = void 0;

function finishMatch(nextState, callback) {
    var _computeChangedRoutes = (0, _computeChangedRoutes3.default)(state, nextState);

var leaveRoutes = _computeChangedRoutes.leaveRoutes;
    var changeRoutes = _computeChangedRoutes.changeRoutes;
    var enterRoutes = _computeChangedRoutes.enterRoutes;

(0, _TransitionUtils.runLeaveHooks)(leaveRoutes, state);

// Tear down confirmation hooks for left routes
    leaveRoutes.filter(function (route) {
      return enterRoutes.indexOf(route) === -1;
    }).forEach(removeListenBeforeHooksForRoute);

// change and enter hooks are run in series
    (0, _TransitionUtils.runChangeHooks)(changeRoutes, state, nextState, function (error, redirectInfo) {
      if (error || redirectInfo) return handleErrorOrRedirect(error, redirectInfo);

(0, _TransitionUtils.runEnterHooks)(enterRoutes, nextState, finishEnterHooks);
    });

function finishEnterHooks(error, redirectInfo) {
      if (error || redirectInfo) return handleErrorOrRedirect(error, redirectInfo);

// TODO: Fetch components after state is updated.
      (0, _getComponents2.default)(nextState, function (error, components) {
        if (error) {
          callback(error);
        } else {
          // TODO: Make match a pure function and have some other API
          // for "match and update state".
          callback(null, null, state = _extends({}, nextState, { components: components }));
        }
      });
    }

function handleErrorOrRedirect(error, redirectInfo) {
      if (error) callback(error);else callback(null, redirectInfo);
    }
  }

var RouteGuid = 1;

function getRouteID(route) {
    var create = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];

return route.__id__ || create && (route.__id__ = RouteGuid++);
  }

var RouteHooks = Object.create(null);

function getRouteHooksForRoutes(routes) {
    return routes.reduce(function (hooks, route) {
      hooks.push.apply(hooks, RouteHooks[getRouteID(route)]);
      return hooks;
    }, []);
  }

function transitionHook(location, callback) {
    (0, _matchRoutes2.default)(routes, location, function (error, nextState) {
      if (nextState == null) {
        // TODO: We didn't actually match anything, but hang
        // onto error/nextState so we don't have to matchRoutes
        // again in the listen callback.
        callback();
        return;
      }

// Cache some state here so we don't have to
      // matchRoutes() again in the listen callback.
      partialNextState = _extends({}, nextState, { location: location });

var hooks = getRouteHooksForRoutes((0, _computeChangedRoutes3.default)(state, partialNextState).leaveRoutes);

var result = void 0;
      for (var i = 0, len = hooks.length; result == null && i < len; ++i) {
        // Passing the location arg here indicates to
        // the user that this is a transition hook.
        result = hooks[i](location);
      }

callback(result);
    });
  }

/* istanbul ignore next: untestable with Karma */
  function beforeUnloadHook() {
    // Synchronously check to see if any route hooks want
    // to prevent the current window/tab from closing.
    if (state.routes) {
      var hooks = getRouteHooksForRoutes(state.routes);

var message = void 0;
      for (var i = 0, len = hooks.length; typeof message !== 'string' && i < len; ++i) {
        // Passing no args indicates to the user that this is a
        // beforeunload hook. We don't know the next location.
        message = hooks[i]();
      }

return message;
    }
  }

var unlistenBefore = void 0,
      unlistenBeforeUnload = void 0;

function removeListenBeforeHooksForRoute(route) {
    var routeID = getRouteID(route, false);
    if (!routeID) {
      return;
    }

delete RouteHooks[routeID];

if (!hasAnyProperties(RouteHooks)) {
      // teardown transition & beforeunload hooks
      if (unlistenBefore) {
        unlistenBefore();
        unlistenBefore = null;
      }

if (unlistenBeforeUnload) {
        unlistenBeforeUnload();
        unlistenBeforeUnload = null;
      }
    }
  }

/**
   * Registers the given hook function to run before leaving the given route.
   *
   * During a normal transition, the hook function receives the next location
   * as its only argument and can return either a prompt message (string) to show the user,
   * to make sure they want to leave the page; or `false`, to prevent the transition.
   * Any other return value will have no effect.
   *
   * During the beforeunload event (in browsers) the hook receives no arguments.
   * In this case it must return a prompt message to prevent the transition.
   *
   * Returns a function that may be used to unbind the listener.
   */
  function listenBeforeLeavingRoute(route, hook) {
    // TODO: Warn if they register for a route that isn't currently
    // active. They're probably doing something wrong, like re-creating
    // route objects on every location change.
    var routeID = getRouteID(route);
    var hooks = RouteHooks[routeID];

if (!hooks) {
      var thereWereNoRouteHooks = !hasAnyProperties(RouteHooks);

RouteHooks[routeID] = [hook];

if (thereWereNoRouteHooks) {
        // setup transition & beforeunload hooks
        unlistenBefore = history.listenBefore(transitionHook);

if (history.listenBeforeUnload) unlistenBeforeUnload = history.listenBeforeUnload(beforeUnloadHook);
      }
    } else {
      if (hooks.indexOf(hook) === -1) {
        process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, 'adding multiple leave hooks for the same route is deprecated; manage multiple confirmations in your own code instead') : void 0;

hooks.push(hook);
      }
    }

return function () {
      var hooks = RouteHooks[routeID];

if (hooks) {
        var newHooks = hooks.filter(function (item) {
          return item !== hook;
        });

if (newHooks.length === 0) {
          removeListenBeforeHooksForRoute(route);
        } else {
          RouteHooks[routeID] = newHooks;
        }
      }
    };
  }

/**
   * This is the API for stateful environments. As the location
   * changes, we update state and call the listener. We can also
   * gracefully handle errors and redirects.
   */
  function listen(listener) {
    // TODO: Only use a single history listener. Otherwise we'll
    // end up with multiple concurrent calls to match.
    return history.listen(function (location) {
      if (state.location === location) {
        listener(null, state);
      } else {
        match(location, function (error, redirectLocation, nextState) {
          if (error) {
            listener(error);
          } else if (redirectLocation) {
            history.replace(redirectLocation);
          } else if (nextState) {
            listener(null, nextState);
          } else {
            process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, 'Location "%s" did not match any routes', location.pathname + location.search + location.hash) : void 0;
          }
        });
      }
    });
  }

return {
    isActive: isActive,
    match: match,
    listenBeforeLeavingRoute: listenBeforeLeavingRoute,
    listen: listen
  };
}

//export default useRoutes

module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 310 */
/***/ (function(module, exports, __webpack_require__) {

var getLength = __webpack_require__(1301),
    isLength = __webpack_require__(142);

/**
 * Checks if `value` is array-like.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
 */
function isArrayLike(value) {
  return value != null && isLength(getLength(value));
}

module.exports = isArrayLike;

/***/ }),
/* 311 */
/***/ (function(module, exports) {

/** Used to detect unsigned integer values. */
var reIsUint = /^\d+$/;

/**
 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
 * of an array-like value.
 */
var MAX_SAFE_INTEGER = 9007199254740991;

/**
 * Checks if `value` is a valid array-like index.
 *
 * @private
 * @param {*} value The value to check.
 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
 */
function isIndex(value, length) {
  value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
  length = length == null ? MAX_SAFE_INTEGER : length;
  return value > -1 && value % 1 == 0 && value < length;
}

module.exports = isIndex;

/***/ }),
/* 312 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(502),
    isArrayLike = __webpack_require__(310),
    isObject = __webpack_require__(89),
    shimKeys = __webpack_require__(1306);

/* Native method references for those with the same name as other `lodash` methods. */
var nativeKeys = getNative(Object, 'keys');

/**
 * Creates an array of the own enumerable property names of `object`.
 *
 * **Note:** Non-object values are coerced to objects. See the
 * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)
 * for more details.
 *
 * @static
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.keys(new Foo);
 * // => ['a', 'b'] (iteration order is not guaranteed)
 *
 * _.keys('hi');
 * // => ['0', '1']
 */
var keys = !nativeKeys ? shimKeys : function(object) {
  var Ctor = object == null ? undefined : object.constructor;
  if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
      (typeof object != 'function' && isArrayLike(object))) {
    return shimKeys(object);
  }
  return isObject(object) ? nativeKeys(object) : [];
};

module.exports = keys;

/***/ }),
/* 313 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var SortDirection = {
  /**
   * Sort items in ascending order.
   * This means arranging from the lowest value to the highest (e.g. a-z, 0-9).
   */
  ASC: 'ASC',

/**
   * Sort items in descending order.
   * This means arranging from the highest value to the lowest (e.g. z-a, 9-0).
   */
  DESC: 'DESC'
};

exports.default = SortDirection;

/***/ }),
/* 314 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _ArrowKeyStepper = __webpack_require__(1319);

Object.defineProperty(exports, 'ArrowKeyStepper', {
  enumerable: true,
  get: function get() {
    return _ArrowKeyStepper.ArrowKeyStepper;
  }
});

var _AutoSizer = __webpack_require__(1321);

Object.defineProperty(exports, 'AutoSizer', {
  enumerable: true,
  get: function get() {
    return _AutoSizer.AutoSizer;
  }
});

var _CellMeasurer = __webpack_require__(1323);

Object.defineProperty(exports, 'CellMeasurer', {
  enumerable: true,
  get: function get() {
    return _CellMeasurer.CellMeasurer;
  }
});
Object.defineProperty(exports, 'defaultCellMeasurerCellSizeCache', {
  enumerable: true,
  get: function get() {
    return _CellMeasurer.defaultCellSizeCache;
  }
});
Object.defineProperty(exports, 'uniformSizeCellMeasurerCellSizeCache', {
  enumerable: true,
  get: function get() {
    return _CellMeasurer.defaultCellSizeCache;
  }
});

var _Collection = __webpack_require__(1328);

Object.defineProperty(exports, 'Collection', {
  enumerable: true,
  get: function get() {
    return _Collection.Collection;
  }
});

var _ColumnSizer = __webpack_require__(1331);

Object.defineProperty(exports, 'ColumnSizer', {
  enumerable: true,
  get: function get() {
    return _ColumnSizer.ColumnSizer;
  }
});

var _Table = __webpack_require__(1345);

Object.defineProperty(exports, 'defaultTableCellDataGetter', {
  enumerable: true,
  get: function get() {
    return _Table.defaultCellDataGetter;
  }
});
Object.defineProperty(exports, 'defaultTableCellRenderer', {
  enumerable: true,
  get: function get() {
    return _Table.defaultCellRenderer;
  }
});
Object.defineProperty(exports, 'defaultTableHeaderRenderer', {
  enumerable: true,
  get: function get() {
    return _Table.defaultHeaderRenderer;
  }
});
Object.defineProperty(exports, 'defaultTableRowRenderer', {
  enumerable: true,
  get: function get() {
    return _Table.defaultRowRenderer;
  }
});
Object.defineProperty(exports, 'Table', {
  enumerable: true,
  get: function get() {
    return _Table.Table;
  }
});
Object.defineProperty(exports, 'Column', {
  enumerable: true,
  get: function get() {
    return _Table.Column;
  }
});
Object.defineProperty(exports, 'SortDirection', {
  enumerable: true,
  get: function get() {
    return _Table.SortDirection;
  }
});
Object.defineProperty(exports, 'SortIndicator', {
  enumerable: true,
  get: function get() {
    return _Table.SortIndicator;
  }
});

var _Grid = __webpack_require__(191);

Object.defineProperty(exports, 'defaultCellRangeRenderer', {
  enumerable: true,
  get: function get() {
    return _Grid.defaultCellRangeRenderer;
  }
});
Object.defineProperty(exports, 'Grid', {
  enumerable: true,
  get: function get() {
    return _Grid.Grid;
  }
});

var _InfiniteLoader = __webpack_require__(1339);

Object.defineProperty(exports, 'InfiniteLoader', {
  enumerable: true,
  get: function get() {
    return _InfiniteLoader.InfiniteLoader;
  }
});

var _ScrollSync = __webpack_require__(1343);

Object.defineProperty(exports, 'ScrollSync', {
  enumerable: true,
  get: function get() {
    return _ScrollSync.ScrollSync;
  }
});

var _List = __webpack_require__(1341);

Object.defineProperty(exports, 'List', {
  enumerable: true,
  get: function get() {
    return _List.List;
  }
});

var _WindowScroller = __webpack_require__(1347);

Object.defineProperty(exports, 'WindowScroller', {
  enumerable: true,
  get: function get() {
    return _WindowScroller.WindowScroller;
  }
});

/***/ }),
/* 315 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = createCallbackMemoizer;
/**
 * Helper utility that updates the specified callback whenever any of the specified indices have changed.
 */
function createCallbackMemoizer() {
  var requireAllKeys = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];

var cachedIndices = {};

return function (_ref) {
    var callback = _ref.callback;
    var indices = _ref.indices;

var keys = Object.keys(indices);
    var allInitialized = !requireAllKeys || keys.every(function (key) {
      var value = indices[key];
      return Array.isArray(value) ? value.length > 0 : value >= 0;
    });
    var indexChanged = keys.length !== Object.keys(cachedIndices).length || keys.some(function (key) {
      var cachedValue = cachedIndices[key];
      var value = indices[key];

return Array.isArray(value) ? cachedValue.join(',') !== value.join(',') : cachedValue !== value;
    });

cachedIndices = indices;

if (allInitialized && indexChanged) {
      callback(indices);
    }
  };
}

/***/ }),
/* 316 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var canUseDOM = __webpack_require__(1357);

var size;

module.exports = function (recalc) {
  if (!size || recalc) {
    if (canUseDOM) {
      var scrollDiv = document.createElement('div');

scrollDiv.style.position = 'absolute';
      scrollDiv.style.top = '-9999px';
      scrollDiv.style.width = '50px';
      scrollDiv.style.height = '50px';
      scrollDiv.style.overflow = 'scroll';

document.body.appendChild(scrollDiv);
      size = scrollDiv.offsetWidth - scrollDiv.clientWidth;
      document.body.removeChild(scrollDiv);
    }
  }

return size;
};

/***/ }),
/* 317 */
/***/ (function(module, exports, __webpack_require__) {

var DOMLazyTree = __webpack_require__(113);
var Danger = __webpack_require__(1362);
var ReactMultiChildUpdateTypes = __webpack_require__(532);
var ReactDOMComponentTree = __webpack_require__(28);
var ReactInstrumentation = __webpack_require__(41);

var createMicrosoftUnsafeLocalFunction = __webpack_require__(331);
var setInnerHTML = __webpack_require__(198);
var setTextContent = __webpack_require__(544);

function getNodeAfter(parentNode, node) {
  // Special case for text components, which return [open, close] comments
  // from getHostNode.
  if (Array.isArray(node)) {
    node = node[1];
  }
  return node ? node.nextSibling : parentNode.firstChild;
}

/**
 * Inserts `childNode` as a child of `parentNode` at the `index`.
 *
 * @param {DOMElement} parentNode Parent node in which to insert.
 * @param {DOMElement} childNode Child node to insert.
 * @param {number} index Index at which to insert the child.
 * @internal
 */
var insertChildAt = createMicrosoftUnsafeLocalFunction(function (parentNode, childNode, referenceNode) {
  // We rely exclusively on `insertBefore(node, null)` instead of also using
  // `appendChild(node)`. (Using `undefined` is not allowed by all browsers so
  // we are careful to use `null`.)
  parentNode.insertBefore(childNode, referenceNode);
});

function insertLazyTreeChildAt(parentNode, childTree, referenceNode) {
  DOMLazyTree.insertTreeBefore(parentNode, childTree, referenceNode);
}

function moveChild(parentNode, childNode, referenceNode) {
  if (Array.isArray(childNode)) {
    moveDelimitedText(parentNode, childNode[0], childNode[1], referenceNode);
  } else {
    insertChildAt(parentNode, childNode, referenceNode);
  }
}

function removeChild(parentNode, childNode) {
  if (Array.isArray(childNode)) {
    var closingComment = childNode[1];
    childNode = childNode[0];
    removeDelimitedText(parentNode, childNode, closingComment);
    parentNode.removeChild(closingComment);
  }
  parentNode.removeChild(childNode);
}

if (process.env.NODE_ENV !== 'production') {
    ReactInstrumentation.debugTool.onHostOperation(ReactDOMComponentTree.getInstanceFromNode(openingComment)._debugID, 'replace text', stringText);
  }
}

/**
 * Operations for updating with DOM children.
 */
var DOMChildrenOperations = {

dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup,

replaceDelimitedText: replaceDelimitedText,

/**
   * Updates a component's children by processing a series of updates. The
   * update configurations are each expected to have a `parentNode` property.
   *
   * @param {array<object>} updates List of update configurations.
   * @internal
   */
  processUpdates: function (parentNode, updates) {
    if (process.env.NODE_ENV !== 'production') {
      var parentNodeDebugID = ReactDOMComponentTree.getInstanceFromNode(parentNode)._debugID;
    }

for (var k = 0; k < updates.length; k++) {
      var update = updates[k];
      switch (update.type) {
        case ReactMultiChildUpdateTypes.INSERT_MARKUP:
          insertLazyTreeChildAt(parentNode, update.content, getNodeAfter(parentNode, update.afterNode));
          if (process.env.NODE_ENV !== 'production') {
            ReactInstrumentation.debugTool.onHostOperation(parentNodeDebugID, 'insert child', { toIndex: update.toIndex, content: update.content.toString() });
          }
          break;
        case ReactMultiChildUpdateTypes.MOVE_EXISTING:
          moveChild(parentNode, update.fromNode, getNodeAfter(parentNode, update.afterNode));
          if (process.env.NODE_ENV !== 'production') {
            ReactInstrumentation.debugTool.onHostOperation(parentNodeDebugID, 'move child', { fromIndex: update.fromIndex, toIndex: update.toIndex });
          }
          break;
        case ReactMultiChildUpdateTypes.SET_MARKUP:
          setInnerHTML(parentNode, update.content);
          if (process.env.NODE_ENV !== 'production') {
            ReactInstrumentation.debugTool.onHostOperation(parentNodeDebugID, 'replace children', update.content.toString());
          }
          break;
        case ReactMultiChildUpdateTypes.TEXT_CONTENT:
          setTextContent(parentNode, update.content);
          if (process.env.NODE_ENV !== 'production') {
            ReactInstrumentation.debugTool.onHostOperation(parentNodeDebugID, 'replace text', update.content.toString());
          }
          break;
        case ReactMultiChildUpdateTypes.REMOVE_NODE:
          removeChild(parentNode, update.fromNode);
          if (process.env.NODE_ENV !== 'production') {
            ReactInstrumentation.debugTool.onHostOperation(parentNodeDebugID, 'remove child', { fromIndex: update.fromIndex });
          }
          break;
      }
    }
  }

};

module.exports = DOMChildrenOperations;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 318 */
/***/ (function(module, exports, __webpack_require__) {

var DOMNamespaces = {
  html: 'http://www.w3.org/1999/xhtml',
  mathml: 'http://www.w3.org/1998/Math/MathML',
  svg: 'http://www.w3.org/2000/svg'
};

module.exports = DOMNamespaces;

/***/ }),
/* 319 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var EventConstants = __webpack_require__(62);
var ReactErrorUtils = __webpack_require__(325);

var invariant = __webpack_require__(19);
var warning = __webpack_require__(18);

/**
 * Injected dependencies:
 */

/**
 * - `ComponentTree`: [required] Module that can convert between React instances
 *   and actual node references.
 */
var ComponentTree;
var TreeTraversal;
var injection = {
  injectComponentTree: function (Injected) {
    ComponentTree = Injected;
    if (process.env.NODE_ENV !== 'production') {
      process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, 'EventPluginUtils.injection.injectComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.') : void 0;
    }
  },
  injectTreeTraversal: function (Injected) {
    TreeTraversal = Injected;
    if (process.env.NODE_ENV !== 'production') {
      process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.isAncestor && Injected.getLowestCommonAncestor, 'EventPluginUtils.injection.injectTreeTraversal(...): Injected ' + 'module is missing isAncestor or getLowestCommonAncestor.') : void 0;
    }
  }
};

var topLevelTypes = EventConstants.topLevelTypes;

function isEndish(topLevelType) {
  return topLevelType === topLevelTypes.topMouseUp || topLevelType === topLevelTypes.topTouchEnd || topLevelType === topLevelTypes.topTouchCancel;
}

function isMoveish(topLevelType) {
  return topLevelType === topLevelTypes.topMouseMove || topLevelType === topLevelTypes.topTouchMove;
}
function isStartish(topLevelType) {
  return topLevelType === topLevelTypes.topMouseDown || topLevelType === topLevelTypes.topTouchStart;
}

var validateEventDispatches;
if (process.env.NODE_ENV !== 'production') {
  validateEventDispatches = function (event) {
    var dispatchListeners = event._dispatchListeners;
    var dispatchInstances = event._dispatchInstances;

var listenersIsArr = Array.isArray(dispatchListeners);
    var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;

var instancesIsArr = Array.isArray(dispatchInstances);
    var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;

process.env.NODE_ENV !== 'production' ? warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, 'EventPluginUtils: Invalid `event`.') : void 0;
  };
}

/**
 * Dispatch the event to the listener.
 * @param {SyntheticEvent} event SyntheticEvent to handle
 * @param {boolean} simulated If the event is simulated (changes exn behavior)
 * @param {function} listener Application-level callback
 * @param {*} inst Internal component instance
 */
function executeDispatch(event, simulated, listener, inst) {
  var type = event.type || 'unknown-event';
  event.currentTarget = EventPluginUtils.getNodeFromInstance(inst);
  if (simulated) {
    ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event);
  } else {
    ReactErrorUtils.invokeGuardedCallback(type, listener, event);
  }
  event.currentTarget = null;
}

/**
 * Standard/simple iteration through an event's collected dispatches.
 */
function executeDispatchesInOrder(event, simulated) {
  var dispatchListeners = event._dispatchListeners;
  var dispatchInstances = event._dispatchInstances;
  if (process.env.NODE_ENV !== 'production') {
    validateEventDispatches(event);
  }
  if (Array.isArray(dispatchListeners)) {
    for (var i = 0; i < dispatchListeners.length; i++) {
      if (event.isPropagationStopped()) {
        break;
      }
      // Listeners and Instances are two parallel arrays that are always in sync.
      executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]);
    }
  } else if (dispatchListeners) {
    executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
  }
  event._dispatchListeners = null;
  event._dispatchInstances = null;
}

/**
 * Standard/simple iteration through an event's collected dispatches, but stops
 * at the first dispatch execution returning true, and returns that id.
 *
 * @return {?string} id of the first dispatch execution who's listener returns
 * true, or null if no listener returned true.
 */
function executeDispatchesInOrderStopAtTrueImpl(event) {
  var dispatchListeners = event._dispatchListeners;
  var dispatchInstances = event._dispatchInstances;
  if (process.env.NODE_ENV !== 'production') {
    validateEventDispatches(event);
  }
  if (Array.isArray(dispatchListeners)) {
    for (var i = 0; i < dispatchListeners.length; i++) {
      if (event.isPropagationStopped()) {
        break;
      }
      // Listeners and Instances are two parallel arrays that are always in sync.
      if (dispatchListeners[i](event, dispatchInstances[i])) {
        return dispatchInstances[i];
      }
    }
  } else if (dispatchListeners) {
    if (dispatchListeners(event, dispatchInstances)) {
      return dispatchInstances;
    }
  }
  return null;
}

/**
 * @see executeDispatchesInOrderStopAtTrueImpl
 */
function executeDispatchesInOrderStopAtTrue(event) {
  var ret = executeDispatchesInOrderStopAtTrueImpl(event);
  event._dispatchInstances = null;
  event._dispatchListeners = null;
  return ret;
}

/**
 * Execution of a "direct" dispatch - there must be at most one dispatch
 * accumulated on the event or it is considered an error. It doesn't really make
 * sense for an event with multiple dispatches (bubbled) to keep track of the
 * return values at each dispatch execution, but it does tend to make sense when
 * dealing with "direct" dispatches.
 *
 * @return {*} The return value of executing the single dispatch.
 */
function executeDirectDispatch(event) {
  if (process.env.NODE_ENV !== 'production') {
    validateEventDispatches(event);
  }
  var dispatchListener = event._dispatchListeners;
  var dispatchInstance = event._dispatchInstances;
  !!Array.isArray(dispatchListener) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : _prodInvariant('103') : void 0;
  event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
  var res = dispatchListener ? dispatchListener(event) : null;
  event.currentTarget = null;
  event._dispatchListeners = null;
  event._dispatchInstances = null;
  return res;
}

/**
 * @param {SyntheticEvent} event
 * @return {boolean} True iff number of dispatches accumulated is greater than 0.
 */
function hasDispatches(event) {
  return !!event._dispatchListeners;
}

/**
 * General utilities that are useful in creating custom Event Plugins.
 */
var EventPluginUtils = {
  isEndish: isEndish,
  isMoveish: isMoveish,
  isStartish: isStartish,

executeDirectDispatch: executeDirectDispatch,
  executeDispatchesInOrder: executeDispatchesInOrder,
  executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
  hasDispatches: hasDispatches,

getInstanceFromNode: function (node) {
    return ComponentTree.getInstanceFromNode(node);
  },
  getNodeFromInstance: function (node) {
    return ComponentTree.getNodeFromInstance(node);
  },
  isAncestor: function (a, b) {
    return TreeTraversal.isAncestor(a, b);
  },
  getLowestCommonAncestor: function (a, b) {
    return TreeTraversal.getLowestCommonAncestor(a, b);
  },
  getParentInstance: function (inst) {
    return TreeTraversal.getParentInstance(inst);
  },
  traverseTwoPhase: function (target, fn, arg) {
    return TreeTraversal.traverseTwoPhase(target, fn, arg);
  },
  traverseEnterLeave: function (from, to, fn, argFrom, argTo) {
    return TreeTraversal.traverseEnterLeave(from, to, fn, argFrom, argTo);
  },

injection: injection
};

module.exports = EventPluginUtils;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 320 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * Escape and wrap key so it is safe to use as a reactid
 *
 * @param {string} key to be escaped.
 * @return {string} the escaped key.
 */

function escape(key) {
  var escapeRegex = /[=:]/g;
  var escaperLookup = {
    '=': '=0',
    ':': '=2'
  };
  var escapedString = ('' + key).replace(escapeRegex, function (match) {
    return escaperLookup[match];
  });

return '$' + escapedString;
}

/**
 * Unescape and unwrap key for human-readable display
 *
 * @param {string} key to unescape.
 * @return {string} the unescaped key.
 */
function unescape(key) {
  var unescapeRegex = /(=0|=2)/g;
  var unescaperLookup = {
    '=0': '=',
    '=2': ':'
  };
  var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);

return ('' + keySubstring).replace(unescapeRegex, function (match) {
    return unescaperLookup[match];
  });
}

var KeyEscapeUtils = {
  escape: escape,
  unescape: unescape
};

module.exports = KeyEscapeUtils;

/***/ }),
/* 321 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var ReactPropTypes = __webpack_require__(534);
var ReactPropTypeLocations = __webpack_require__(195);
var ReactPropTypesSecret = __webpack_require__(328);

var invariant = __webpack_require__(19);
var warning = __webpack_require__(18);

var hasReadOnlyValue = {
  'button': true,
  'checkbox': true,
  'image': true,
  'hidden': true,
  'radio': true,
  'reset': true,
  'submit': true
};

function _assertSingleLink(inputProps) {
  !(inputProps.checkedLink == null || inputProps.valueLink == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a valueLink. If you want to use checkedLink, you probably don\'t want to use valueLink and vice versa.') : _prodInvariant('87') : void 0;
}
function _assertValueLink(inputProps) {
  _assertSingleLink(inputProps);
  !(inputProps.value == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a valueLink and a value or onChange event. If you want to use value or onChange, you probably don\'t want to use valueLink.') : _prodInvariant('88') : void 0;
}

function _assertCheckedLink(inputProps) {
  _assertSingleLink(inputProps);
  !(inputProps.checked == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a checked property or onChange event. If you want to use checked or onChange, you probably don\'t want to use checkedLink') : _prodInvariant('89') : void 0;
}

/**
 * Provide a linked `value` attribute for controlled forms. You should not use
 * this outside of the ReactDOM controlled form components.
 */
var LinkedValueUtils = {
  checkPropTypes: function (tagName, props, owner) {
    for (var propName in propTypes) {
      if (propTypes.hasOwnProperty(propName)) {
        var error = propTypes[propName](props, propName, tagName, ReactPropTypeLocations.prop, null, ReactPropTypesSecret);
      }
      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
        // Only monitor this failure once because there tends to be a lot of the
        // same error.
        loggedTypeFailures[error.message] = true;

var addendum = getDeclarationErrorAddendum(owner);
        process.env.NODE_ENV !== 'production' ? warning(false, 'Failed form propType: %s%s', error.message, addendum) : void 0;
      }
    }
  },

/**
   * @param {object} inputProps Props for form component
   * @return {*} current value of the input either from value prop or link.
   */
  getValue: function (inputProps) {
    if (inputProps.valueLink) {
      _assertValueLink(inputProps);
      return inputProps.valueLink.value;
    }
    return inputProps.value;
  },

/**
   * @param {object} inputProps Props for form component
   * @return {*} current checked status of the input either from checked prop
   *             or link.
   */
  getChecked: function (inputProps) {
    if (inputProps.checkedLink) {
      _assertCheckedLink(inputProps);
      return inputProps.checkedLink.value;
    }
    return inputProps.checked;
  },

/**
   * @param {object} inputProps Props for form component
   * @param {SyntheticEvent} event change event to handle
   */
  executeOnChange: function (inputProps, event) {
    if (inputProps.valueLink) {
      _assertValueLink(inputProps);
      return inputProps.valueLink.requestChange(event.target.value);
    } else if (inputProps.checkedLink) {
      _assertCheckedLink(inputProps);
      return inputProps.checkedLink.requestChange(event.target.checked);
    } else if (inputProps.onChange) {
      return inputProps.onChange.call(undefined, event);
    }
  }
};

module.exports = LinkedValueUtils;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 322 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var ReactNoopUpdateQueue = __webpack_require__(326);

var canDefineProperty = __webpack_require__(330);
var emptyObject = __webpack_require__(131);
var invariant = __webpack_require__(19);
var warning = __webpack_require__(18);

/**
 * Base class helpers for the updating state of a component.
 */
function ReactComponent(props, context, updater) {
  this.props = props;
  this.context = context;
  this.refs = emptyObject;
  // We initialize the default updater but the real one gets injected by the
  // renderer.
  this.updater = updater || ReactNoopUpdateQueue;
}

ReactComponent.prototype.isReactComponent = {};

/**
 * Sets a subset of the state. Always use this to mutate
 * state. You should treat `this.state` as immutable.
 *
 * There is no guarantee that `this.state` will be immediately updated, so
 * accessing `this.state` after calling this method may return the old value.
 *
 * There is no guarantee that calls to `setState` will run synchronously,
 * as they may eventually be batched together.  You can provide an optional
 * callback that will be executed when the call to setState is actually
 * completed.
 *
 * When a function is provided to setState, it will be called at some point in
 * the future (not synchronously). It will be called with the up to date
 * component arguments (state, props, context). These values can be different
 * from this.* because your function may be called after receiveProps but before
 * shouldComponentUpdate, and this new state, props, and context will not yet be
 * assigned to this.
 *
 * @param {object|function} partialState Next partial state or function to
 *        produce next partial state to be merged with current state.
 * @param {?function} callback Called after state is updated.
 * @final
 * @protected
 */
ReactComponent.prototype.setState = function (partialState, callback) {
  !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : _prodInvariant('85') : void 0;
  this.updater.enqueueSetState(this, partialState);
  if (callback) {
    this.updater.enqueueCallback(this, callback, 'setState');
  }
};

/**
 * Forces an update. This should only be invoked when it is known with
 * certainty that we are **not** in a DOM transaction.
 *
 * You may want to call this when you know that some deeper aspect of the
 * component's state has changed but `setState` was not called.
 *
 * This will not invoke `shouldComponentUpdate`, but it will invoke
 * `componentWillUpdate` and `componentDidUpdate`.
 *
 * @param {?function} callback Called after update is complete.
 * @final
 * @protected
 */
ReactComponent.prototype.forceUpdate = function (callback) {
  this.updater.enqueueForceUpdate(this);
  if (callback) {
    this.updater.enqueueCallback(this, callback, 'forceUpdate');
  }
};

/**
 * Deprecated APIs. These APIs used to exist on classic React classes but since
 * we would like to deprecate them, we're not going to move them over to this
 * modern base class. Instead, we define a getter that warns if it's accessed.
 */
if (process.env.NODE_ENV !== 'production') {
  var deprecatedAPIs = {
    isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
    replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
  };
  var defineDeprecationWarning = function (methodName, info) {
    if (canDefineProperty) {
      Object.defineProperty(ReactComponent.prototype, methodName, {
        get: function () {
          process.env.NODE_ENV !== 'production' ? warning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]) : void 0;
          return undefined;
        }
      });
    }
  };
  for (var fnName in deprecatedAPIs) {
    if (deprecatedAPIs.hasOwnProperty(fnName)) {
      defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
    }
  }
}

module.exports = ReactComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 323 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var invariant = __webpack_require__(19);

var injected = false;

var ReactComponentEnvironment = {

/**
   * Optionally injectable hook for swapping out mount images in the middle of
   * the tree.
   */
  replaceNodeWithMarkup: null,

/**
   * Optionally injectable hook for processing a queue of child updates. Will
   * later move into MultiChildComponents.
   */
  processChildrenUpdates: null,

injection: {
    injectEnvironment: function (environment) {
      !!injected ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactCompositeComponent: injectEnvironment() can only be called once.') : _prodInvariant('104') : void 0;
      ReactComponentEnvironment.replaceNodeWithMarkup = environment.replaceNodeWithMarkup;
      ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates;
      injected = true;
    }
  }

};

module.exports = ReactComponentEnvironment;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 324 */
/***/ (function(module, exports, __webpack_require__) {

var shallowCompare = __webpack_require__(545);

/**
 * If your React component's render function is "pure", e.g. it will render the
 * same result given the same props and state, provide this mixin for a
 * considerable performance boost.
 *
 * Most React components have pure render functions.
 *
 * Example:
 *
 *   var ReactComponentWithPureRenderMixin =
 *     require('ReactComponentWithPureRenderMixin');
 *   React.createClass({
 *     mixins: [ReactComponentWithPureRenderMixin],
 *
 *     render: function() {
 *       return <div className={this.props.className}>foo</div>;
 *     }
 *   });
 *
 * Note: This only checks shallow equality for props and state. If these contain
 * complex data structures this mixin may have false-negatives for deeper
 * differences. Only mixin to components which have simple props and state, or
 * use `forceUpdate()` when you know deep data structures have changed.
 *
 * See https://facebook.github.io/react/docs/pure-render-mixin.html
 */
var ReactComponentWithPureRenderMixin = {
  shouldComponentUpdate: function (nextProps, nextState) {
    return shallowCompare(this, nextProps, nextState);
  }
};

module.exports = ReactComponentWithPureRenderMixin;

/***/ }),
/* 325 */
/***/ (function(module, exports, __webpack_require__) {

var caughtError = null;

/**
 * Call a function while guarding against errors that happens within it.
 *
 * @param {?String} name of the guard to use for logging or debugging
 * @param {Function} func The function to invoke
 * @param {*} a First argument
 * @param {*} b Second argument
 */
function invokeGuardedCallback(name, func, a, b) {
  try {
    return func(a, b);
  } catch (x) {
    if (caughtError === null) {
      caughtError = x;
    }
    return undefined;
  }
}

var ReactErrorUtils = {
  invokeGuardedCallback: invokeGuardedCallback,

/**
   * Invoked by ReactTestUtils.Simulate so that any errors thrown by the event
   * handler are sure to be rethrown by rethrowCaughtError.
   */
  invokeGuardedCallbackWithCatch: invokeGuardedCallback,

/**
   * During execution of guarded functions we will capture the first error which
   * we will rethrow to be handled by the top level error handler.
   */
  rethrowCaughtError: function () {
    if (caughtError) {
      var error = caughtError;
      caughtError = null;
      throw error;
    }
  }
};

if (process.env.NODE_ENV !== 'production') {
  /**
   * To help development we can get better devtools integration by simulating a
   * real browser event.
   */
  if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {
    var fakeNode = document.createElement('react');
    ReactErrorUtils.invokeGuardedCallback = function (name, func, a, b) {
      var boundFunc = func.bind(null, a, b);
      var evtType = 'react-' + name;
      fakeNode.addEventListener(evtType, boundFunc, false);
      var evt = document.createEvent('Event');
      evt.initEvent(evtType, false, false);
      fakeNode.dispatchEvent(evt);
      fakeNode.removeEventListener(evtType, boundFunc, false);
    };
  }
}

module.exports = ReactErrorUtils;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 326 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
 * Copyright 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule ReactNoopUpdateQueue
 */

var warning = __webpack_require__(18);

function warnNoop(publicInstance, callerName) {
  if (process.env.NODE_ENV !== 'production') {
    var constructor = publicInstance.constructor;
    process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;
  }
}

/**
 * This is the abstract API for an update queue.
 */
var ReactNoopUpdateQueue = {

/**
   * Forces an update. This should only be invoked when it is known with
   * certainty that we are **not** in a DOM transaction.
   *
   * You may want to call this when you know that some deeper aspect of the
   * component's state has changed but `setState` was not called.
   *
   * This will not invoke `shouldComponentUpdate`, but it will invoke
   * `componentWillUpdate` and `componentDidUpdate`.
   *
   * @param {ReactClass} publicInstance The instance that should rerender.
   * @internal
   */
  enqueueForceUpdate: function (publicInstance) {
    warnNoop(publicInstance, 'forceUpdate');
  },

/**
   * Replaces all of the state. Always use this or `setState` to mutate state.
   * You should treat `this.state` as immutable.
   *
   * There is no guarantee that `this.state` will be immediately updated, so
   * accessing `this.state` after calling this method may return the old value.
   *
   * @param {ReactClass} publicInstance The instance that should rerender.
   * @param {object} completeState Next state.
   * @internal
   */
  enqueueReplaceState: function (publicInstance, completeState) {
    warnNoop(publicInstance, 'replaceState');
  },

module.exports = ReactNoopUpdateQueue;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 327 */
/***/ (function(module, exports, __webpack_require__) {

var ReactPropTypeLocationNames = {};

if (process.env.NODE_ENV !== 'production') {
  ReactPropTypeLocationNames = {
    prop: 'prop',
    context: 'context',
    childContext: 'child context'
  };
}

module.exports = ReactPropTypeLocationNames;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 328 */
/***/ (function(module, exports, __webpack_require__) {

var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

module.exports = ReactPropTypesSecret;

/***/ }),
/* 329 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var ReactCurrentOwner = __webpack_require__(63);
var ReactInstanceMap = __webpack_require__(146);
var ReactInstrumentation = __webpack_require__(41);
var ReactUpdates = __webpack_require__(57);

var invariant = __webpack_require__(19);
var warning = __webpack_require__(18);

function enqueueUpdate(internalInstance) {
  ReactUpdates.enqueueUpdate(internalInstance);
}

function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
  var internalInstance = ReactInstanceMap.get(publicInstance);
  if (!internalInstance) {
    if (process.env.NODE_ENV !== 'production') {
      var ctor = publicInstance.constructor;
      // Only warn when we have a callerName. Otherwise we should be silent.
      // We're probably calling from enqueueCallback. We don't want to warn
      // there because we already warned for the corresponding lifecycle method.
      process.env.NODE_ENV !== 'production' ? warning(!callerName, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, ctor && (ctor.displayName || ctor.name) || 'ReactClass') : void 0;
    }
    return null;
  }

if (process.env.NODE_ENV !== 'production') {
    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '%s(...): Cannot update during an existing state transition (such as ' + 'within `render` or another component\'s constructor). Render methods ' + 'should be a pure function of props and state; constructor ' + 'side-effects are an anti-pattern, but can be moved to ' + '`componentWillMount`.', callerName) : void 0;
  }

return internalInstance;
}

/**
 * ReactUpdateQueue allows for state updates to be scheduled into a later
 * reconciliation step.
 */
var ReactUpdateQueue = {

/**
   * Checks whether or not this composite component is mounted.
   * @param {ReactClass} publicInstance The instance we want to test.
   * @return {boolean} True if mounted, false otherwise.
   * @protected
   * @final
   */
  isMounted: function (publicInstance) {
    if (process.env.NODE_ENV !== 'production') {
      var owner = ReactCurrentOwner.current;
      if (owner !== null) {
        process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing isMounted inside its render() function. ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : void 0;
        owner._warnedAboutRefsInRender = true;
      }
    }
    var internalInstance = ReactInstanceMap.get(publicInstance);
    if (internalInstance) {
      // During componentWillMount and render this will still be null but after
      // that will always render to something. At least for now. So we can use
      // this hack.
      return !!internalInstance._renderedComponent;
    } else {
      return false;
    }
  },

/**
   * Enqueue a callback that will be executed after all the pending updates
   * have processed.
   *
   * @param {ReactClass} publicInstance The instance to use as `this` context.
   * @param {?function} callback Called after state is updated.
   * @param {string} callerName Name of the calling function in the public API.
   * @internal
   */
  enqueueCallback: function (publicInstance, callback, callerName) {
    ReactUpdateQueue.validateCallback(callback, callerName);
    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);

// Previously we would throw an error if we didn't have an internal
    // instance. Since we want to make it a no-op instead, we mirror the same
    // behavior we have in other enqueue* methods.
    // We also need to ignore callbacks in componentWillMount. See
    // enqueueUpdates.
    if (!internalInstance) {
      return null;
    }

if (internalInstance._pendingCallbacks) {
      internalInstance._pendingCallbacks.push(callback);
    } else {
      internalInstance._pendingCallbacks = [callback];
    }
    // TODO: The callback here is ignored when setState is called from
    // componentWillMount. Either fix it or disallow doing so completely in
    // favor of getInitialState. Alternatively, we can disallow
    // componentWillMount during server-side rendering.
    enqueueUpdate(internalInstance);
  },

enqueueCallbackInternal: function (internalInstance, callback) {
    if (internalInstance._pendingCallbacks) {
      internalInstance._pendingCallbacks.push(callback);
    } else {
      internalInstance._pendingCallbacks = [callback];
    }
    enqueueUpdate(internalInstance);
  },

/**
   * Forces an update. This should only be invoked when it is known with
   * certainty that we are **not** in a DOM transaction.
   *
   * You may want to call this when you know that some deeper aspect of the
   * component's state has changed but `setState` was not called.
   *
   * This will not invoke `shouldComponentUpdate`, but it will invoke
   * `componentWillUpdate` and `componentDidUpdate`.
   *
   * @param {ReactClass} publicInstance The instance that should rerender.
   * @internal
   */
  enqueueForceUpdate: function (publicInstance) {
    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'forceUpdate');

if (!internalInstance) {
      return;
    }

internalInstance._pendingForceUpdate = true;

enqueueUpdate(internalInstance);
  },

if (!internalInstance) {
      return;
    }

internalInstance._pendingStateQueue = [completeState];
    internalInstance._pendingReplaceState = true;

enqueueUpdate(internalInstance);
  },

/**
   * Sets a subset of the state. This only exists because _pendingState is
   * internal. This provides a merging strategy that is not available to deep
   * properties which is confusing. TODO: Expose pendingState or don't use it
   * during the merge.
   *
   * @param {ReactClass} publicInstance The instance that should rerender.
   * @param {object} partialState Next partial state to be merged with state.
   * @internal
   */
  enqueueSetState: function (publicInstance, partialState) {
    if (process.env.NODE_ENV !== 'production') {
      ReactInstrumentation.debugTool.onSetState();
      process.env.NODE_ENV !== 'production' ? warning(partialState != null, 'setState(...): You passed an undefined or null state object; ' + 'instead, use forceUpdate().') : void 0;
    }

var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'setState');

if (!internalInstance) {
      return;
    }

var queue = internalInstance._pendingStateQueue || (internalInstance._pendingStateQueue = []);
    queue.push(partialState);

enqueueUpdate(internalInstance);
  },

enqueueElementInternal: function (internalInstance, nextElement, nextContext) {
    internalInstance._pendingElement = nextElement;
    // TODO: introduce _pendingContext instead of setting it directly.
    internalInstance._context = nextContext;
    enqueueUpdate(internalInstance);
  },

validateCallback: function (callback, callerName) {
    !(!callback || typeof callback === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s(...): Expected the last optional `callback` argument to be a function. Instead received: %s.', callerName, formatUnexpectedArgument(callback)) : _prodInvariant('122', callerName, formatUnexpectedArgument(callback)) : void 0;
  }

};

module.exports = ReactUpdateQueue;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 330 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = canDefineProperty;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 331 */
/***/ (function(module, exports, __webpack_require__) {

/* globals MSApp */

/**
 * Create a function which has 'unsafe' privileges (required by windows8 apps)
 */

module.exports = createMicrosoftUnsafeLocalFunction;

/***/ }),
/* 332 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * `charCode` represents the actual "character code" and is safe to use with
 * `String.fromCharCode`. As such, only keys that correspond to printable
 * characters produce a valid `charCode`, the only exception to this is Enter.
 * The Tab-key is considered non-printable and does not have a `charCode`,
 * presumably because it does not produce a tab-character in browsers.
 *
 * @param {object} nativeEvent Native browser event.
 * @return {number} Normalized `charCode` property.
 */

function getEventCharCode(nativeEvent) {
  var charCode;
  var keyCode = nativeEvent.keyCode;

if ('charCode' in nativeEvent) {
    charCode = nativeEvent.charCode;

// FF does not set `charCode` for the Enter-key, check against `keyCode`.
    if (charCode === 0 && keyCode === 13) {
      charCode = 13;
    }
  } else {
    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
    charCode = keyCode;
  }

// Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
  // Must not discard the (non-)printable Enter-key.
  if (charCode >= 32 || charCode === 13) {
    return charCode;
  }

return 0;
}

module.exports = getEventCharCode;

/***/ }),
/* 333 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * Translation from modifier key to the associated property in the event.
 * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
 */

var modifierKeyToProp = {
  'Alt': 'altKey',
  'Control': 'ctrlKey',
  'Meta': 'metaKey',
  'Shift': 'shiftKey'
};

// IE8 does not implement getModifierState so we simply map it to the only
// modifier keys exposed by the event itself, does not support Lock-keys.
// Currently, all major browsers except Chrome seems to support Lock-keys.
function modifierStateGetter(keyArg) {
  var syntheticEvent = this;
  var nativeEvent = syntheticEvent.nativeEvent;
  if (nativeEvent.getModifierState) {
    return nativeEvent.getModifierState(keyArg);
  }
  var keyProp = modifierKeyToProp[keyArg];
  return keyProp ? !!nativeEvent[keyProp] : false;
}

function getEventModifierState(nativeEvent) {
  return modifierStateGetter;
}

module.exports = getEventModifierState;

/***/ }),
/* 334 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * Gets the target node from a native browser event by accounting for
 * inconsistencies in browser DOM APIs.
 *
 * @param {object} nativeEvent Native browser event.
 * @return {DOMEventTarget} Target node.
 */

function getEventTarget(nativeEvent) {
  var target = nativeEvent.target || nativeEvent.srcElement || window;

// Normalize SVG <use> element events #4963
  if (target.correspondingUseElement) {
    target = target.correspondingUseElement;
  }

// Safari may fire events on text nodes (Node.TEXT_NODE is 3).
  // @see http://www.quirksmode.org/js/events_properties.html
  return target.nodeType === 3 ? target.parentNode : target;
}

module.exports = getEventTarget;

/***/ }),
/* 335 */
/***/ (function(module, exports, __webpack_require__) {

/* global Symbol */

var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.

/**
 * Returns the iterator method function contained on the iterable object.
 *
 * Be sure to invoke the function with the iterable as context:
 *
 *     var iteratorFn = getIteratorFn(myIterable);
 *     if (iteratorFn) {
 *       var iterator = iteratorFn.call(myIterable);
 *       ...
 *     }
 *
 * @param {?object} maybeIterable
 * @return {?function}
 */
function getIteratorFn(maybeIterable) {
  var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
  if (typeof iteratorFn === 'function') {
    return iteratorFn;
  }
}

module.exports = getIteratorFn;

/***/ }),
/* 336 */
/***/ (function(module, exports, __webpack_require__) {

var ExecutionEnvironment = __webpack_require__(30);

var useHasFeature;
if (ExecutionEnvironment.canUseDOM) {
  useHasFeature = document.implementation && document.implementation.hasFeature &&
  // always returns true in newer browsers as per the standard.
  // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
  document.implementation.hasFeature('', '') !== true;
}

/**
 * Checks if an event is supported in the current execution environment.
 *
 * NOTE: This will not work correctly for non-generic events such as `change`,
 * `reset`, `load`, `error`, and `select`.
 *
 * Borrows from Modernizr.
 *
 * @param {string} eventNameSuffix Event name, e.g. "click".
 * @param {?boolean} capture Check if the capture phase is supported.
 * @return {boolean} True if the event is supported.
 * @internal
 * @license Modernizr 3.0.0pre (Custom Build) | MIT
 */
function isEventSupported(eventNameSuffix, capture) {
  if (!ExecutionEnvironment.canUseDOM || capture && !('addEventListener' in document)) {
    return false;
  }

var eventName = 'on' + eventNameSuffix;
  var isSupported = eventName in document;

if (!isSupported) {
    var element = document.createElement('div');
    element.setAttribute(eventName, 'return;');
    isSupported = typeof element[eventName] === 'function';
  }

if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {
    // This is the only way to test support for the `wheel` event in IE9+.
    isSupported = document.implementation.hasFeature('Events.wheel', '3.0');
  }

return isSupported;
}

module.exports = isEventSupported;

/***/ }),
/* 337 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * Given a `prevElement` and `nextElement`, determines if the existing
 * instance should be updated as opposed to being destroyed or replaced by a new
 * instance. Both arguments are elements. This ensures that this logic can
 * operate on stateless trees without any backing instance.
 *
 * @param {?object} prevElement
 * @param {?object} nextElement
 * @return {boolean} True if the existing instance should be updated.
 * @protected
 */

function shouldUpdateReactComponent(prevElement, nextElement) {
  var prevEmpty = prevElement === null || prevElement === false;
  var nextEmpty = nextElement === null || nextElement === false;
  if (prevEmpty || nextEmpty) {
    return prevEmpty === nextEmpty;
  }

var prevType = typeof prevElement;
  var nextType = typeof nextElement;
  if (prevType === 'string' || prevType === 'number') {
    return nextType === 'string' || nextType === 'number';
  } else {
    return nextType === 'object' && prevElement.type === nextElement.type && prevElement.key === nextElement.key;
  }
}

module.exports = shouldUpdateReactComponent;

/***/ }),
/* 338 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var ReactCurrentOwner = __webpack_require__(63);
var ReactElement = __webpack_require__(51);

var getIteratorFn = __webpack_require__(335);
var invariant = __webpack_require__(19);
var KeyEscapeUtils = __webpack_require__(320);
var warning = __webpack_require__(18);

var SEPARATOR = '.';
var SUBSEPARATOR = ':';

/**
 * TODO: Test that a single child and an array with one item have the same key
 * pattern.
 */

var didWarnAboutMaps = false;

/**
 * Generate a key string that identifies a component within a set.
 *
 * @param {*} component A component that could contain a manual key.
 * @param {number} index Index that is used if a manual key is not provided.
 * @return {string}
 */
function getComponentKey(component, index) {
  // Do some typechecking here since we call this blindly. We want to ensure
  // that we don't block potential future ES APIs.
  if (component && typeof component === 'object' && component.key != null) {
    // Explicit key
    return KeyEscapeUtils.escape(component.key);
  }
  // Implicit key determined by the index in the set
  return index.toString(36);
}

/**
 * @param {?*} children Children tree container.
 * @param {!string} nameSoFar Name of the key path so far.
 * @param {!function} callback Callback to invoke with each child found.
 * @param {?*} traverseContext Used to pass information throughout the traversal
 * process.
 * @return {!number} The number of children in this subtree.
 */
function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
  var type = typeof children;

if (type === 'undefined' || type === 'boolean') {
    // All of the above are perceived as null.
    children = null;
  }

if (children === null || type === 'string' || type === 'number' || ReactElement.isValidElement(children)) {
    callback(traverseContext, children,
    // If it's the only child, treat the name as if it was wrapped in an array
    // so that it's consistent if the number of children grows.
    nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
    return 1;
  }

var child;
  var nextName;
  var subtreeCount = 0; // Count of children found in the current subtree.
  var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;

if (Array.isArray(children)) {
    for (var i = 0; i < children.length; i++) {
      child = children[i];
      nextName = nextNamePrefix + getComponentKey(child, i);
      subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
    }
  } else {
    var iteratorFn = getIteratorFn(children);
    if (iteratorFn) {
      var iterator = iteratorFn.call(children);
      var step;
      if (iteratorFn !== children.entries) {
        var ii = 0;
        while (!(step = iterator.next()).done) {
          child = step.value;
          nextName = nextNamePrefix + getComponentKey(child, ii++);
          subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
        }
      } else {
        if (process.env.NODE_ENV !== 'production') {
          var mapsAsChildrenAddendum = '';
          if (ReactCurrentOwner.current) {
            var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName();
            if (mapsAsChildrenOwnerName) {
              mapsAsChildrenAddendum = ' Check the render method of `' + mapsAsChildrenOwnerName + '`.';
            }
          }
          process.env.NODE_ENV !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.%s', mapsAsChildrenAddendum) : void 0;
          didWarnAboutMaps = true;
        }
        // Iterator will provide entry [k,v] tuples rather than values.
        while (!(step = iterator.next()).done) {
          var entry = step.value;
          if (entry) {
            child = entry[1];
            nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);
            subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
          }
        }
      }
    } else if (type === 'object') {
      var addendum = '';
      if (process.env.NODE_ENV !== 'production') {
        addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';
        if (children._isReactElement) {
          addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.';
        }
        if (ReactCurrentOwner.current) {
          var name = ReactCurrentOwner.current.getName();
          if (name) {
            addendum += ' Check the render method of `' + name + '`.';
          }
        }
      }
      var childrenString = String(children);
       true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : _prodInvariant('31', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : void 0;
    }
  }

return subtreeCount;
}

/**
 * Traverses children that are typically specified as `props.children`, but
 * might also be specified through attributes:
 *
 * - `traverseAllChildren(this.props.children, ...)`
 * - `traverseAllChildren(this.props.leftPanelChildren, ...)`
 *
 * The `traverseContext` is an optional argument that is passed through the
 * entire traversal. It can be used to store accumulations or anything else that
 * the callback might find relevant.
 *
 * @param {?*} children Children tree object.
 * @param {!function} callback To invoke upon traversing each child.
 * @param {?*} traverseContext Context for traversal.
 * @return {!number} The number of children in this subtree.
 */
function traverseAllChildren(children, callback, traverseContext) {
  if (children == null) {
    return 0;
  }

return traverseAllChildrenImpl(children, '', callback, traverseContext);
}

module.exports = traverseAllChildren;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 339 */
/***/ (function(module, exports, __webpack_require__) {

var _assign = __webpack_require__(24);

var emptyFunction = __webpack_require__(44);
var warning = __webpack_require__(18);

var validateDOMNesting = emptyFunction;

if (process.env.NODE_ENV !== 'production') {
  // This validation code was written based on the HTML5 parsing spec:
  // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
  //
  // Note: this does not catch all invalid nesting, nor does it try to (as it's
  // not clear what practical benefit doing so provides); instead, we warn only
  // for cases where the parser will give a parse tree differing from what React
  // intended. For example, <b><div></div></b> is invalid but we don't warn
  // because it still parses correctly; we do warn for other cases like nested
  // <p> tags where the beginning of the second element implicitly closes the
  // first, causing a confusing mess.

// https://html.spec.whatwg.org/multipage/syntax.html#special
  var specialTags = ['address', 'applet', 'area', 'article', 'aside', 'base', 'basefont', 'bgsound', 'blockquote', 'body', 'br', 'button', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dir', 'div', 'dl', 'dt', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'iframe', 'img', 'input', 'isindex', 'li', 'link', 'listing', 'main', 'marquee', 'menu', 'menuitem', 'meta', 'nav', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'p', 'param', 'plaintext', 'pre', 'script', 'section', 'select', 'source', 'style', 'summary', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul', 'wbr', 'xmp'];

// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
  var inScopeTags = ['applet', 'caption', 'html', 'table', 'td', 'th', 'marquee', 'object', 'template',

// https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
  // TODO: Distinguish by namespace here -- for <title>, including it here
  // errs on the side of fewer warnings
  'foreignObject', 'desc', 'title'];

// https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
  var buttonScopeTags = inScopeTags.concat(['button']);

// https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
  var impliedEndTags = ['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt'];

var emptyAncestorInfo = {
    current: null,

formTag: null,
    aTagInScope: null,
    buttonTagInScope: null,
    nobrTagInScope: null,
    pTagInButtonScope: null,

listItemTagAutoclosing: null,
    dlItemTagAutoclosing: null
  };

var updatedAncestorInfo = function (oldInfo, tag, instance) {
    var ancestorInfo = _assign({}, oldInfo || emptyAncestorInfo);
    var info = { tag: tag, instance: instance };

if (inScopeTags.indexOf(tag) !== -1) {
      ancestorInfo.aTagInScope = null;
      ancestorInfo.buttonTagInScope = null;
      ancestorInfo.nobrTagInScope = null;
    }
    if (buttonScopeTags.indexOf(tag) !== -1) {
      ancestorInfo.pTagInButtonScope = null;
    }

// See rules for 'li', 'dd', 'dt' start tags in
    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
    if (specialTags.indexOf(tag) !== -1 && tag !== 'address' && tag !== 'div' && tag !== 'p') {
      ancestorInfo.listItemTagAutoclosing = null;
      ancestorInfo.dlItemTagAutoclosing = null;
    }

ancestorInfo.current = info;

if (tag === 'form') {
      ancestorInfo.formTag = info;
    }
    if (tag === 'a') {
      ancestorInfo.aTagInScope = info;
    }
    if (tag === 'button') {
      ancestorInfo.buttonTagInScope = info;
    }
    if (tag === 'nobr') {
      ancestorInfo.nobrTagInScope = info;
    }
    if (tag === 'p') {
      ancestorInfo.pTagInButtonScope = info;
    }
    if (tag === 'li') {
      ancestorInfo.listItemTagAutoclosing = info;
    }
    if (tag === 'dd' || tag === 'dt') {
      ancestorInfo.dlItemTagAutoclosing = info;
    }

return ancestorInfo;
  };

/**
   * Returns whether
   */
  var isTagValidWithParent = function (tag, parentTag) {
    // First, let's check if we're in an unusual parsing mode...
    switch (parentTag) {
      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
      case 'select':
        return tag === 'option' || tag === 'optgroup' || tag === '#text';
      case 'optgroup':
        return tag === 'option' || tag === '#text';
      // Strictly speaking, seeing an <option> doesn't mean we're in a <select>
      // but
      case 'option':
        return tag === '#text';

// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
      // No special behavior since these rules fall back to "in body" mode for
      // all except special table nodes which cause bad parsing behavior anyway.

// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
      case 'tr':
        return tag === 'th' || tag === 'td' || tag === 'style' || tag === 'script' || tag === 'template';

// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
      case 'tbody':
      case 'thead':
      case 'tfoot':
        return tag === 'tr' || tag === 'style' || tag === 'script' || tag === 'template';

// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
      case 'colgroup':
        return tag === 'col' || tag === 'template';

// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
      case 'table':
        return tag === 'caption' || tag === 'colgroup' || tag === 'tbody' || tag === 'tfoot' || tag === 'thead' || tag === 'style' || tag === 'script' || tag === 'template';

// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
      case 'head':
        return tag === 'base' || tag === 'basefont' || tag === 'bgsound' || tag === 'link' || tag === 'meta' || tag === 'title' || tag === 'noscript' || tag === 'noframes' || tag === 'style' || tag === 'script' || tag === 'template';

// https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
      case 'html':
        return tag === 'head' || tag === 'body';
      case '#document':
        return tag === 'html';
    }

// Probably in the "in body" parsing mode, so we outlaw only tag combos
    // where the parsing rules cause implicit opens or closes to be added.
    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
    switch (tag) {
      case 'h1':
      case 'h2':
      case 'h3':
      case 'h4':
      case 'h5':
      case 'h6':
        return parentTag !== 'h1' && parentTag !== 'h2' && parentTag !== 'h3' && parentTag !== 'h4' && parentTag !== 'h5' && parentTag !== 'h6';

case 'rp':
      case 'rt':
        return impliedEndTags.indexOf(parentTag) === -1;

case 'body':
      case 'caption':
      case 'col':
      case 'colgroup':
      case 'frame':
      case 'head':
      case 'html':
      case 'tbody':
      case 'td':
      case 'tfoot':
      case 'th':
      case 'thead':
      case 'tr':
        // These tags are only valid with a few parents that have special child
        // parsing rules -- if we're down here, then none of those matched and
        // so we allow it only if we don't know what the parent is, as all other
        // cases are invalid.
        return parentTag == null;
    }

return true;
  };

/**
   * Returns whether
   */
  var findInvalidAncestorForTag = function (tag, ancestorInfo) {
    switch (tag) {
      case 'address':
      case 'article':
      case 'aside':
      case 'blockquote':
      case 'center':
      case 'details':
      case 'dialog':
      case 'dir':
      case 'div':
      case 'dl':
      case 'fieldset':
      case 'figcaption':
      case 'figure':
      case 'footer':
      case 'header':
      case 'hgroup':
      case 'main':
      case 'menu':
      case 'nav':
      case 'ol':
      case 'p':
      case 'section':
      case 'summary':
      case 'ul':

case 'pre':
      case 'listing':

case 'table':

case 'hr':

case 'xmp':

case 'h1':
      case 'h2':
      case 'h3':
      case 'h4':
      case 'h5':
      case 'h6':
        return ancestorInfo.pTagInButtonScope;

case 'form':
        return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;

case 'li':
        return ancestorInfo.listItemTagAutoclosing;

case 'dd':
      case 'dt':
        return ancestorInfo.dlItemTagAutoclosing;

case 'button':
        return ancestorInfo.buttonTagInScope;

case 'a':
        // Spec says something about storing a list of markers, but it sounds
        // equivalent to this check.
        return ancestorInfo.aTagInScope;

case 'nobr':
        return ancestorInfo.nobrTagInScope;
    }

return null;
  };

/**
   * Given a ReactCompositeComponent instance, return a list of its recursive
   * owners, starting at the root and ending with the instance itself.
   */
  var findOwnerStack = function (instance) {
    if (!instance) {
      return [];
    }

var stack = [];
    do {
      stack.push(instance);
    } while (instance = instance._currentElement._owner);
    stack.reverse();
    return stack;
  };

var didWarn = {};

validateDOMNesting = function (childTag, childText, childInstance, ancestorInfo) {
    ancestorInfo = ancestorInfo || emptyAncestorInfo;
    var parentInfo = ancestorInfo.current;
    var parentTag = parentInfo && parentInfo.tag;

if (childText != null) {
      process.env.NODE_ENV !== 'production' ? warning(childTag == null, 'validateDOMNesting: when childText is passed, childTag should be null') : void 0;
      childTag = '#text';
    }

var invalidParent = isTagValidWithParent(childTag, parentTag) ? null : parentInfo;
    var invalidAncestor = invalidParent ? null : findInvalidAncestorForTag(childTag, ancestorInfo);
    var problematic = invalidParent || invalidAncestor;

if (problematic) {
      var ancestorTag = problematic.tag;
      var ancestorInstance = problematic.instance;

var childOwner = childInstance && childInstance._currentElement._owner;
      var ancestorOwner = ancestorInstance && ancestorInstance._currentElement._owner;

var childOwners = findOwnerStack(childOwner);
      var ancestorOwners = findOwnerStack(ancestorOwner);

var minStackLen = Math.min(childOwners.length, ancestorOwners.length);
      var i;

var deepestCommon = -1;
      for (i = 0; i < minStackLen; i++) {
        if (childOwners[i] === ancestorOwners[i]) {
          deepestCommon = i;
        } else {
          break;
        }
      }

var UNKNOWN = '(unknown)';
      var childOwnerNames = childOwners.slice(deepestCommon + 1).map(function (inst) {
        return inst.getName() || UNKNOWN;
      });
      var ancestorOwnerNames = ancestorOwners.slice(deepestCommon + 1).map(function (inst) {
        return inst.getName() || UNKNOWN;
      });
      var ownerInfo = [].concat(
      // If the parent and child instances have a common owner ancestor, start
      // with that -- otherwise we just start with the parent's owners.
      deepestCommon !== -1 ? childOwners[deepestCommon].getName() || UNKNOWN : [], ancestorOwnerNames, ancestorTag,
      // If we're warning about an invalid (non-parent) ancestry, add '...'
      invalidAncestor ? ['...'] : [], childOwnerNames, childTag).join(' > ');

var warnKey = !!invalidParent + '|' + childTag + '|' + ancestorTag + '|' + ownerInfo;
      if (didWarn[warnKey]) {
        return;
      }
      didWarn[warnKey] = true;

if (invalidParent) {
        var info = '';
        if (ancestorTag === 'table' && childTag === 'tr') {
          info += ' Add a <tbody> to your code to match the DOM tree generated by ' + 'the browser.';
        }
        process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): %s cannot appear as a child of <%s>.%s ' + 'See %s.%s', tagDisplayName, ancestorTag, whitespaceInfo, ownerInfo, info) : void 0;
      } else {
        process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): %s cannot appear as a descendant of ' + '<%s>. See %s.', tagDisplayName, ancestorTag, ownerInfo) : void 0;
      }
    }
  };

validateDOMNesting.updatedAncestorInfo = updatedAncestorInfo;

// For testing
  validateDOMNesting.isTagValidInContext = function (tag, ancestorInfo) {
    ancestorInfo = ancestorInfo || emptyAncestorInfo;
    var parentInfo = ancestorInfo.current;
    var parentTag = parentInfo && parentInfo.tag;
    return isTagValidWithParent(tag, parentTag) && !findInvalidAncestorForTag(tag, ancestorInfo);
  };
}

module.exports = validateDOMNesting;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 340 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.compose = exports.applyMiddleware = exports.bindActionCreators = exports.combineReducers = exports.createStore = undefined;

var _createStore = __webpack_require__(547);

var _createStore2 = _interopRequireDefault(_createStore);

var _combineReducers = __webpack_require__(1437);

var _combineReducers2 = _interopRequireDefault(_combineReducers);

var _bindActionCreators = __webpack_require__(1436);

var _bindActionCreators2 = _interopRequireDefault(_bindActionCreators);

var _applyMiddleware = __webpack_require__(1435);

var _applyMiddleware2 = _interopRequireDefault(_applyMiddleware);

var _compose = __webpack_require__(546);

var _compose2 = _interopRequireDefault(_compose);

var _warning = __webpack_require__(548);

var _warning2 = _interopRequireDefault(_warning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/*
* This is a dummy function to check if the function name has been altered by minification.
* If the function has been minified and NODE_ENV !== 'production', warn the user.
*/
function isCrushed() {}

if (process.env.NODE_ENV !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {
  (0, _warning2["default"])('You are currently using minified code outside of NODE_ENV === \'production\'. ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or DefinePlugin for webpack (http://stackoverflow.com/questions/30030031) ' + 'to ensure you have the correct code for your production build.');
}

exports.createStore = _createStore2["default"];
exports.combineReducers = _combineReducers2["default"];
exports.bindActionCreators = _bindActionCreators2["default"];
exports.applyMiddleware = _applyMiddleware2["default"];
exports.compose = _compose2["default"];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 341 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* WEBPACK VAR INJECTION */(function(global) {/**
 * A collection of shims that provide minimal functionality of the ES6 collections.
 *
 * These implementations are not meant to be used outside of the ResizeObserver
 * modules as they cover only a limited range of use cases.
 */
/* eslint-disable require-jsdoc, valid-jsdoc */
var MapShim = (function () {
    if (typeof Map !== 'undefined') {
        return Map;
    }
    /**
     * Returns index in provided array that matches the specified key.
     *
     * @param {Array<Array>} arr
     * @param {*} key
     * @returns {number}
     */
    function getIndex(arr, key) {
        var result = -1;
        arr.some(function (entry, index) {
            if (entry[0] === key) {
                result = index;
                return true;
            }
            return false;
        });
        return result;
    }
    return /** @class */ (function () {
        function class_1() {
            this.__entries__ = [];
        }
        Object.defineProperty(class_1.prototype, "size", {
            /**
             * @returns {boolean}
             */
            get: function () {
                return this.__entries__.length;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @param {*} key
         * @returns {*}
         */
        class_1.prototype.get = function (key) {
            var index = getIndex(this.__entries__, key);
            var entry = this.__entries__[index];
            return entry && entry[1];
        };
        /**
         * @param {*} key
         * @param {*} value
         * @returns {void}
         */
        class_1.prototype.set = function (key, value) {
            var index = getIndex(this.__entries__, key);
            if (~index) {
                this.__entries__[index][1] = value;
            }
            else {
                this.__entries__.push([key, value]);
            }
        };
        /**
         * @param {*} key
         * @returns {void}
         */
        class_1.prototype.delete = function (key) {
            var entries = this.__entries__;
            var index = getIndex(entries, key);
            if (~index) {
                entries.splice(index, 1);
            }
        };
        /**
         * @param {*} key
         * @returns {void}
         */
        class_1.prototype.has = function (key) {
            return !!~getIndex(this.__entries__, key);
        };
        /**
         * @returns {void}
         */
        class_1.prototype.clear = function () {
            this.__entries__.splice(0);
        };
        /**
         * @param {Function} callback
         * @param {*} [ctx=null]
         * @returns {void}
         */
        class_1.prototype.forEach = function (callback, ctx) {
            if (ctx === void 0) { ctx = null; }
            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
                var entry = _a[_i];
                callback.call(ctx, entry[1], entry[0]);
            }
        };
        return class_1;
    }());
})();

/**
 * Detects whether window and document objects are available in current environment.
 */
var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;

// Returns global object of a current environment.
var global$1 = (function () {
    if (typeof global !== 'undefined' && global.Math === Math) {
        return global;
    }
    if (typeof self !== 'undefined' && self.Math === Math) {
        return self;
    }
    if (typeof window !== 'undefined' && window.Math === Math) {
        return window;
    }
    // eslint-disable-next-line no-new-func
    return Function('return this')();
})();

/**
 * A shim for the requestAnimationFrame which falls back to the setTimeout if
 * first one is not supported.
 *
 * @returns {number} Requests' identifier.
 */
var requestAnimationFrame$1 = (function () {
    if (typeof requestAnimationFrame === 'function') {
        // It's required to use a bounded function because IE sometimes throws
        // an "Invalid calling object" error if rAF is invoked without the global
        // object on the left hand side.
        return requestAnimationFrame.bind(global$1);
    }
    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };
})();

// Defines minimum timeout before adding a trailing call.
var trailingTimeout = 2;
/**
 * Creates a wrapper function which ensures that provided callback will be
 * invoked only once during the specified delay period.
 *
 * @param {Function} callback - Function to be invoked after the delay period.
 * @param {number} delay - Delay after which to invoke callback.
 * @returns {Function}
 */
function throttle (callback, delay) {
    var leadingCall = false, trailingCall = false, lastCallTime = 0;
    /**
     * Invokes the original callback function and schedules new invocation if
     * the "proxy" was called during current request.
     *
     * @returns {void}
     */
    function resolvePending() {
        if (leadingCall) {
            leadingCall = false;
            callback();
        }
        if (trailingCall) {
            proxy();
        }
    }
    /**
     * Callback invoked after the specified delay. It will further postpone
     * invocation of the original function delegating it to the
     * requestAnimationFrame.
     *
     * @returns {void}
     */
    function timeoutCallback() {
        requestAnimationFrame$1(resolvePending);
    }
    /**
     * Schedules invocation of the original function.
     *
     * @returns {void}
     */
    function proxy() {
        var timeStamp = Date.now();
        if (leadingCall) {
            // Reject immediately following calls.
            if (timeStamp - lastCallTime < trailingTimeout) {
                return;
            }
            // Schedule new call to be in invoked when the pending one is resolved.
            // This is important for "transitions" which never actually start
            // immediately so there is a chance that we might miss one if change
            // happens amids the pending invocation.
            trailingCall = true;
        }
        else {
            leadingCall = true;
            trailingCall = false;
            setTimeout(timeoutCallback, delay);
        }
        lastCallTime = timeStamp;
    }
    return proxy;
}

// Minimum delay before invoking the update of observers.
var REFRESH_DELAY = 20;
// A list of substrings of CSS properties used to find transition events that
// might affect dimensions of observed elements.
var transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
// Check if MutationObserver is available.
var mutationObserverSupported = typeof MutationObserver !== 'undefined';
/**
 * Singleton controller class which handles updates of ResizeObserver instances.
 */
var ResizeObserverController = /** @class */ (function () {
    /**
     * Creates a new instance of ResizeObserverController.
     *
     * @private
     */
    function ResizeObserverController() {
        /**
         * Indicates whether DOM listeners have been added.
         *
         * @private {boolean}
         */
        this.connected_ = false;
        /**
         * Tells that controller has subscribed for Mutation Events.
         *
         * @private {boolean}
         */
        this.mutationEventsAdded_ = false;
        /**
         * Keeps reference to the instance of MutationObserver.
         *
         * @private {MutationObserver}
         */
        this.mutationsObserver_ = null;
        /**
         * A list of connected observers.
         *
         * @private {Array<ResizeObserverSPI>}
         */
        this.observers_ = [];
        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
    }
    /**
     * Adds observer to observers list.
     *
     * @param {ResizeObserverSPI} observer - Observer to be added.
     * @returns {void}
     */
    ResizeObserverController.prototype.addObserver = function (observer) {
        if (!~this.observers_.indexOf(observer)) {
            this.observers_.push(observer);
        }
        // Add listeners if they haven't been added yet.
        if (!this.connected_) {
            this.connect_();
        }
    };
    /**
     * Removes observer from observers list.
     *
     * @param {ResizeObserverSPI} observer - Observer to be removed.
     * @returns {void}
     */
    ResizeObserverController.prototype.removeObserver = function (observer) {
        var observers = this.observers_;
        var index = observers.indexOf(observer);
        // Remove observer if it's present in registry.
        if (~index) {
            observers.splice(index, 1);
        }
        // Remove listeners if controller has no connected observers.
        if (!observers.length && this.connected_) {
            this.disconnect_();
        }
    };
    /**
     * Invokes the update of observers. It will continue running updates insofar
     * it detects changes.
     *
     * @returns {void}
     */
    ResizeObserverController.prototype.refresh = function () {
        var changesDetected = this.updateObservers_();
        // Continue running updates if changes have been detected as there might
        // be future ones caused by CSS transitions.
        if (changesDetected) {
            this.refresh();
        }
    };
    /**
     * Updates every observer from observers list and notifies them of queued
     * entries.
     *
     * @private
     * @returns {boolean} Returns "true" if any observer has detected changes in
     *      dimensions of it's elements.
     */
    ResizeObserverController.prototype.updateObservers_ = function () {
        // Collect observers that have active observations.
        var activeObservers = this.observers_.filter(function (observer) {
            return observer.gatherActive(), observer.hasActive();
        });
        // Deliver notifications in a separate cycle in order to avoid any
        // collisions between observers, e.g. when multiple instances of
        // ResizeObserver are tracking the same element and the callback of one
        // of them changes content dimensions of the observed target. Sometimes
        // this may result in notifications being blocked for the rest of observers.
        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });
        return activeObservers.length > 0;
    };
    /**
     * Initializes DOM listeners.
     *
     * @private
     * @returns {void}
     */
    ResizeObserverController.prototype.connect_ = function () {
        // Do nothing if running in a non-browser environment or if listeners
        // have been already added.
        if (!isBrowser || this.connected_) {
            return;
        }
        // Subscription to the "Transitionend" event is used as a workaround for
        // delayed transitions. This way it's possible to capture at least the
        // final state of an element.
        document.addEventListener('transitionend', this.onTransitionEnd_);
        window.addEventListener('resize', this.refresh);
        if (mutationObserverSupported) {
            this.mutationsObserver_ = new MutationObserver(this.refresh);
            this.mutationsObserver_.observe(document, {
                attributes: true,
                childList: true,
                characterData: true,
                subtree: true
            });
        }
        else {
            document.addEventListener('DOMSubtreeModified', this.refresh);
            this.mutationEventsAdded_ = true;
        }
        this.connected_ = true;
    };
    /**
     * Removes DOM listeners.
     *
     * @private
     * @returns {void}
     */
    ResizeObserverController.prototype.disconnect_ = function () {
        // Do nothing if running in a non-browser environment or if listeners
        // have been already removed.
        if (!isBrowser || !this.connected_) {
            return;
        }
        document.removeEventListener('transitionend', this.onTransitionEnd_);
        window.removeEventListener('resize', this.refresh);
        if (this.mutationsObserver_) {
            this.mutationsObserver_.disconnect();
        }
        if (this.mutationEventsAdded_) {
            document.removeEventListener('DOMSubtreeModified', this.refresh);
        }
        this.mutationsObserver_ = null;
        this.mutationEventsAdded_ = false;
        this.connected_ = false;
    };
    /**
     * "Transitionend" event handler.
     *
     * @private
     * @param {TransitionEvent} event
     * @returns {void}
     */
    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {
        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;
        // Detect whether transition may affect dimensions of an element.
        var isReflowProperty = transitionKeys.some(function (key) {
            return !!~propertyName.indexOf(key);
        });
        if (isReflowProperty) {
            this.refresh();
        }
    };
    /**
     * Returns instance of the ResizeObserverController.
     *
     * @returns {ResizeObserverController}
     */
    ResizeObserverController.getInstance = function () {
        if (!this.instance_) {
            this.instance_ = new ResizeObserverController();
        }
        return this.instance_;
    };
    /**
     * Holds reference to the controller's instance.
     *
     * @private {ResizeObserverController}
     */
    ResizeObserverController.instance_ = null;
    return ResizeObserverController;
}());

/**
 * Defines non-writable/enumerable properties of the provided target object.
 *
 * @param {Object} target - Object for which to define properties.
 * @param {Object} props - Properties to be defined.
 * @returns {Object} Target object.
 */
var defineConfigurable = (function (target, props) {
    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {
        var key = _a[_i];
        Object.defineProperty(target, key, {
            value: props[key],
            enumerable: false,
            writable: false,
            configurable: true
        });
    }
    return target;
});

/**
 * Returns the global object associated with provided element.
 *
 * @param {Object} target
 * @returns {Object}
 */
var getWindowOf = (function (target) {
    // Assume that the element is an instance of Node, which means that it
    // has the "ownerDocument" property from which we can retrieve a
    // corresponding global object.
    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
    // Return the local global object if it's not possible extract one from
    // provided element.
    return ownerGlobal || global$1;
});

// Placeholder of an empty content rectangle.
var emptyRect = createRectInit(0, 0, 0, 0);
/**
 * Converts provided string to a number.
 *
 * @param {number|string} value
 * @returns {number}
 */
function toFloat(value) {
    return parseFloat(value) || 0;
}
/**
 * Extracts borders size from provided styles.
 *
 * @param {CSSStyleDeclaration} styles
 * @param {...string} positions - Borders positions (top, right, ...)
 * @returns {number}
 */
function getBordersSize(styles) {
    var positions = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        positions[_i - 1] = arguments[_i];
    }
    return positions.reduce(function (size, position) {
        var value = styles['border-' + position + '-width'];
        return size + toFloat(value);
    }, 0);
}
/**
 * Extracts paddings sizes from provided styles.
 *
 * @param {CSSStyleDeclaration} styles
 * @returns {Object} Paddings box.
 */
function getPaddings(styles) {
    var positions = ['top', 'right', 'bottom', 'left'];
    var paddings = {};
    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {
        var position = positions_1[_i];
        var value = styles['padding-' + position];
        paddings[position] = toFloat(value);
    }
    return paddings;
}
/**
 * Calculates content rectangle of provided SVG element.
 *
 * @param {SVGGraphicsElement} target - Element content rectangle of which needs
 *      to be calculated.
 * @returns {DOMRectInit}
 */
function getSVGContentRect(target) {
    var bbox = target.getBBox();
    return createRectInit(0, 0, bbox.width, bbox.height);
}
/**
 * Calculates content rectangle of provided HTMLElement.
 *
 * @param {HTMLElement} target - Element for which to calculate the content rectangle.
 * @returns {DOMRectInit}
 */
function getHTMLElementContentRect(target) {
    // Client width & height properties can't be
    // used exclusively as they provide rounded values.
    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;
    // By this condition we can catch all non-replaced inline, hidden and
    // detached elements. Though elements with width & height properties less
    // than 0.5 will be discarded as well.
    //
    // Without it we would need to implement separate methods for each of
    // those cases and it's not possible to perform a precise and performance
    // effective test for hidden elements. E.g. even jQuery's ':visible' filter
    // gives wrong results for elements with width & height less than 0.5.
    if (!clientWidth && !clientHeight) {
        return emptyRect;
    }
    var styles = getWindowOf(target).getComputedStyle(target);
    var paddings = getPaddings(styles);
    var horizPad = paddings.left + paddings.right;
    var vertPad = paddings.top + paddings.bottom;
    // Computed styles of width & height are being used because they are the
    // only dimensions available to JS that contain non-rounded values. It could
    // be possible to utilize the getBoundingClientRect if only it's data wasn't
    // affected by CSS transformations let alone paddings, borders and scroll bars.
    var width = toFloat(styles.width), height = toFloat(styles.height);
    // Width & height include paddings and borders when the 'border-box' box
    // model is applied (except for IE).
    if (styles.boxSizing === 'border-box') {
        // Following conditions are required to handle Internet Explorer which
        // doesn't include paddings and borders to computed CSS dimensions.
        //
        // We can say that if CSS dimensions + paddings are equal to the "client"
        // properties then it's either IE, and thus we don't need to subtract
        // anything, or an element merely doesn't have paddings/borders styles.
        if (Math.round(width + horizPad) !== clientWidth) {
            width -= getBordersSize(styles, 'left', 'right') + horizPad;
        }
        if (Math.round(height + vertPad) !== clientHeight) {
            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;
        }
    }
    // Following steps can't be applied to the document's root element as its
    // client[Width/Height] properties represent viewport area of the window.
    // Besides, it's as well not necessary as the <html> itself neither has
    // rendered scroll bars nor it can be clipped.
    if (!isDocumentElement(target)) {
        // In some browsers (only in Firefox, actually) CSS width & height
        // include scroll bars size which can be removed at this step as scroll
        // bars are the only difference between rounded dimensions + paddings
        // and "client" properties, though that is not always true in Chrome.
        var vertScrollbar = Math.round(width + horizPad) - clientWidth;
        var horizScrollbar = Math.round(height + vertPad) - clientHeight;
        // Chrome has a rather weird rounding of "client" properties.
        // E.g. for an element with content width of 314.2px it sometimes gives
        // the client width of 315px and for the width of 314.7px it may give
        // 314px. And it doesn't happen all the time. So just ignore this delta
        // as a non-relevant.
        if (Math.abs(vertScrollbar) !== 1) {
            width -= vertScrollbar;
        }
        if (Math.abs(horizScrollbar) !== 1) {
            height -= horizScrollbar;
        }
    }
    return createRectInit(paddings.left, paddings.top, width, height);
}
/**
 * Checks whether provided element is an instance of the SVGGraphicsElement.
 *
 * @param {Element} target - Element to be checked.
 * @returns {boolean}
 */
var isSVGGraphicsElement = (function () {
    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement
    // interface.
    if (typeof SVGGraphicsElement !== 'undefined') {
        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };
    }
    // If it's so, then check that element is at least an instance of the
    // SVGElement and that it has the "getBBox" method.
    // eslint-disable-next-line no-extra-parens
    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&
        typeof target.getBBox === 'function'); };
})();
/**
 * Checks whether provided element is a document element (<html>).
 *
 * @param {Element} target - Element to be checked.
 * @returns {boolean}
 */
function isDocumentElement(target) {
    return target === getWindowOf(target).document.documentElement;
}
/**
 * Calculates an appropriate content rectangle for provided html or svg element.
 *
 * @param {Element} target - Element content rectangle of which needs to be calculated.
 * @returns {DOMRectInit}
 */
function getContentRect(target) {
    if (!isBrowser) {
        return emptyRect;
    }
    if (isSVGGraphicsElement(target)) {
        return getSVGContentRect(target);
    }
    return getHTMLElementContentRect(target);
}
/**
 * Creates rectangle with an interface of the DOMRectReadOnly.
 * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly
 *
 * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.
 * @returns {DOMRectReadOnly}
 */
function createReadOnlyRect(_a) {
    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;
    // If DOMRectReadOnly is available use it as a prototype for the rectangle.
    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
    var rect = Object.create(Constr.prototype);
    // Rectangle's properties are not writable and non-enumerable.
    defineConfigurable(rect, {
        x: x, y: y, width: width, height: height,
        top: y,
        right: x + width,
        bottom: height + y,
        left: x
    });
    return rect;
}
/**
 * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.
 * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit
 *
 * @param {number} x - X coordinate.
 * @param {number} y - Y coordinate.
 * @param {number} width - Rectangle's width.
 * @param {number} height - Rectangle's height.
 * @returns {DOMRectInit}
 */
function createRectInit(x, y, width, height) {
    return { x: x, y: y, width: width, height: height };
}

/**
 * Class that is responsible for computations of the content rectangle of
 * provided DOM element and for keeping track of it's changes.
 */
var ResizeObservation = /** @class */ (function () {
    /**
     * Creates an instance of ResizeObservation.
     *
     * @param {Element} target - Element to be observed.
     */
    function ResizeObservation(target) {
        /**
         * Broadcasted width of content rectangle.
         *
         * @type {number}
         */
        this.broadcastWidth = 0;
        /**
         * Broadcasted height of content rectangle.
         *
         * @type {number}
         */
        this.broadcastHeight = 0;
        /**
         * Reference to the last observed content rectangle.
         *
         * @private {DOMRectInit}
         */
        this.contentRect_ = createRectInit(0, 0, 0, 0);
        this.target = target;
    }
    /**
     * Updates content rectangle and tells whether it's width or height properties
     * have changed since the last broadcast.
     *
     * @returns {boolean}
     */
    ResizeObservation.prototype.isActive = function () {
        var rect = getContentRect(this.target);
        this.contentRect_ = rect;
        return (rect.width !== this.broadcastWidth ||
            rect.height !== this.broadcastHeight);
    };
    /**
     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data
     * from the corresponding properties of the last observed content rectangle.
     *
     * @returns {DOMRectInit} Last observed content rectangle.
     */
    ResizeObservation.prototype.broadcastRect = function () {
        var rect = this.contentRect_;
        this.broadcastWidth = rect.width;
        this.broadcastHeight = rect.height;
        return rect;
    };
    return ResizeObservation;
}());

// Registry of internal observers. If WeakMap is not available use current shim
// for the Map collection as it has all required methods and because WeakMap
// can't be fully polyfilled anyway.
var observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();
/**
 * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
 * exposing only those methods and properties that are defined in the spec.
 */
var ResizeObserver = /** @class */ (function () {
    /**
     * Creates a new instance of ResizeObserver.
     *
     * @param {ResizeObserverCallback} callback - Callback that is invoked when
     *      dimensions of the observed elements change.
     */
    function ResizeObserver(callback) {
        if (!(this instanceof ResizeObserver)) {
            throw new TypeError('Cannot call a class as a function.');
        }
        if (!arguments.length) {
            throw new TypeError('1 argument required, but only 0 present.');
        }
        var controller = ResizeObserverController.getInstance();
        var observer = new ResizeObserverSPI(callback, controller, this);
        observers.set(this, observer);
    }
    return ResizeObserver;
}());
// Expose public methods of ResizeObserver.
[
    'observe',
    'unobserve',
    'disconnect'
].forEach(function (method) {
    ResizeObserver.prototype[method] = function () {
        var _a;
        return (_a = observers.get(this))[method].apply(_a, arguments);
    };
});

var index = (function () {
    // Export existing implementation if available.
    if (typeof global$1.ResizeObserver !== 'undefined') {
        return global$1.ResizeObserver;
    }
    return ResizeObserver;
})();

/* harmony default export */ __webpack_exports__["default"] = (index);

/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(29)))

/***/ }),
/* 342 */
/***/ (function(module, exports, __webpack_require__) {

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
var stylesInDom = {},
	memoize = function(fn) {
		var memo;
		return function () {
			if (typeof memo === "undefined") memo = fn.apply(this, arguments);
			return memo;
		};
	},
	isOldIE = memoize(function() {
		// Test for IE <= 9 as proposed by Browserhacks
		// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
		// Tests for existence of standard globals is to allow style-loader 
		// to operate correctly into non-standard environments
		// @see https://github.com/webpack-contrib/style-loader/issues/177
		return window && document && document.all && !window.atob;
	}),
	getElement = (function(fn) {
		var memo = {};
		return function(selector) {
			if (typeof memo[selector] === "undefined") {
				memo[selector] = fn.call(this, selector);
			}
			return memo[selector]
		};
	})(function (styleTarget) {
		return document.querySelector(styleTarget)
	}),
	singletonElement = null,
	singletonCounter = 0,
	styleElementsInsertedAtTop = [],
	fixUrls = __webpack_require__(1453);

module.exports = function(list, options) {
	if(typeof DEBUG !== "undefined" && DEBUG) {
		if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
	}

options = options || {};
	options.attrs = typeof options.attrs === "object" ? options.attrs : {};

// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
	// tags it will allow on a page
	if (typeof options.singleton === "undefined") options.singleton = isOldIE();

// By default, add <style> tags to the <head> element
	if (typeof options.insertInto === "undefined") options.insertInto = "head";

// By default, add <style> tags to the bottom of the target
	if (typeof options.insertAt === "undefined") options.insertAt = "bottom";

var styles = listToStyles(list);
	addStylesToDom(styles, options);

return function update(newList) {
		var mayRemove = [];
		for(var i = 0; i < styles.length; i++) {
			var item = styles[i];
			var domStyle = stylesInDom[item.id];
			domStyle.refs--;
			mayRemove.push(domStyle);
		}
		if(newList) {
			var newStyles = listToStyles(newList);
			addStylesToDom(newStyles, options);
		}
		for(var i = 0; i < mayRemove.length; i++) {
			var domStyle = mayRemove[i];
			if(domStyle.refs === 0) {
				for(var j = 0; j < domStyle.parts.length; j++)
					domStyle.parts[j]();
				delete stylesInDom[domStyle.id];
			}
		}
	};
};

function removeStyleElement(styleElement) {
	styleElement.parentNode.removeChild(styleElement);
	var idx = styleElementsInsertedAtTop.indexOf(styleElement);
	if(idx >= 0) {
		styleElementsInsertedAtTop.splice(idx, 1);
	}
}

function createStyleElement(options) {
	var styleElement = document.createElement("style");
	options.attrs.type = "text/css";

attachTagAttrs(styleElement, options.attrs);
	insertStyleElement(options, styleElement);
	return styleElement;
}

function createLinkElement(options) {
	var linkElement = document.createElement("link");
	options.attrs.type = "text/css";
	options.attrs.rel = "stylesheet";

attachTagAttrs(linkElement, options.attrs);
	insertStyleElement(options, linkElement);
	return linkElement;
}

function attachTagAttrs(element, attrs) {
	Object.keys(attrs).forEach(function (key) {
		element.setAttribute(key, attrs[key]);
	});
}

function addStyle(obj, options) {
	var styleElement, update, remove;

if (options.singleton) {
		var styleIndex = singletonCounter++;
		styleElement = singletonElement || (singletonElement = createStyleElement(options));
		update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
		remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
	} else if(obj.sourceMap &&
		typeof URL === "function" &&
		typeof URL.createObjectURL === "function" &&
		typeof URL.revokeObjectURL === "function" &&
		typeof Blob === "function" &&
		typeof btoa === "function") {
		styleElement = createLinkElement(options);
		update = updateLink.bind(null, styleElement, options);
		remove = function() {
			removeStyleElement(styleElement);
			if(styleElement.href)
				URL.revokeObjectURL(styleElement.href);
		};
	} else {
		styleElement = createStyleElement(options);
		update = applyToTag.bind(null, styleElement);
		remove = function() {
			removeStyleElement(styleElement);
		};
	}

update(obj);

return function updateStyle(newObj) {
		if(newObj) {
			if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
				return;
			update(obj = newObj);
		} else {
			remove();
		}
	};
}

var replaceText = (function () {
	var textStore = [];

return function (index, replacement) {
		textStore[index] = replacement;
		return textStore.filter(Boolean).join('\n');
	};
})();

function applyToSingletonTag(styleElement, index, remove, obj) {
	var css = remove ? "" : obj.css;

if (styleElement.styleSheet) {
		styleElement.styleSheet.cssText = replaceText(index, css);
	} else {
		var cssNode = document.createTextNode(css);
		var childNodes = styleElement.childNodes;
		if (childNodes[index]) styleElement.removeChild(childNodes[index]);
		if (childNodes.length) {
			styleElement.insertBefore(cssNode, childNodes[index]);
		} else {
			styleElement.appendChild(cssNode);
		}
	}
}

function applyToTag(styleElement, obj) {
	var css = obj.css;
	var media = obj.media;

if(media) {
		styleElement.setAttribute("media", media)
	}

if(styleElement.styleSheet) {
		styleElement.styleSheet.cssText = css;
	} else {
		while(styleElement.firstChild) {
			styleElement.removeChild(styleElement.firstChild);
		}
		styleElement.appendChild(document.createTextNode(css));
	}
}

function updateLink(linkElement, options, obj) {
	var css = obj.css;
	var sourceMap = obj.sourceMap;

/* If convertToAbsoluteUrls isn't defined, but sourcemaps are enabled
	and there is no publicPath defined then lets turn convertToAbsoluteUrls
	on by default.  Otherwise default to the convertToAbsoluteUrls option
	directly
	*/
	var autoFixUrls = options.convertToAbsoluteUrls === undefined && sourceMap;

if (options.convertToAbsoluteUrls || autoFixUrls){
		css = fixUrls(css);
	}

if(sourceMap) {
		// http://stackoverflow.com/a/26603875
		css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
	}

var blob = new Blob([css], { type: "text/css" });

var oldSrc = linkElement.href;

linkElement.href = URL.createObjectURL(blob);

if(oldSrc)
		URL.revokeObjectURL(oldSrc);
}

/***/ }),
/* 343 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__components_Icon__ = __webpack_require__(557);
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return __WEBPACK_IMPORTED_MODULE_0__components_Icon__["a"]; });

/***/ }),
/* 344 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_css_animation_es_Event__ = __webpack_require__(398);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__util_raf__ = __webpack_require__(598);

var styleForPesudo = void 0;
// Where el is the DOM element you'd like to test for visibility
function isHidden(element) {
    if (process.env.NODE_ENV === 'test') {
        return false;
    }
    return !element || element.offsetParent === null;
}

var Wave = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(Wave, _React$Component);

function Wave() {
        __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default()(this, Wave);

var _this = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Wave.__proto__ || Object.getPrototypeOf(Wave)).apply(this, arguments));

_this.animationStart = false;
        _this.destroy = false;
        _this.onClick = function (node, waveColor) {
            if (!node || isHidden(node) || node.className.indexOf('-leave') >= 0) {
                return;
            }
            var insertExtraNode = _this.props.insertExtraNode;

_this.extraNode = document.createElement('div');
            var extraNode = _this.extraNode;
            extraNode.className = 'ant-click-animating-node';
            var attributeName = _this.getAttributeName();
            node.removeAttribute(attributeName);
            node.setAttribute(attributeName, 'true');
            // Not white or transparnt or grey
            styleForPesudo = styleForPesudo || document.createElement('style');
            if (waveColor && waveColor !== '#ffffff' && waveColor !== 'rgb(255, 255, 255)' && _this.isNotGrey(waveColor) && !/rgba$\d*, \d*, \d*, 0$/.test(waveColor) && // any transparent rgba color
            waveColor !== 'transparent') {
                extraNode.style.borderColor = waveColor;
                styleForPesudo.innerHTML = '[ant-click-animating-without-extra-node]:after { border-color: ' + waveColor + '; }';
                if (!document.body.contains(styleForPesudo)) {
                    document.body.appendChild(styleForPesudo);
                }
            }
            if (insertExtraNode) {
                node.appendChild(extraNode);
            }
            __WEBPACK_IMPORTED_MODULE_6_css_animation_es_Event__["a" /* default */].addStartEventListener(node, _this.onTransitionStart);
            __WEBPACK_IMPORTED_MODULE_6_css_animation_es_Event__["a" /* default */].addEndEventListener(node, _this.onTransitionEnd);
        };
        _this.bindAnimationEvent = function (node) {
            if (!node || !node.getAttribute || node.getAttribute('disabled') || node.className.indexOf('disabled') >= 0) {
                return;
            }
            var onClick = function onClick(e) {
                // Fix radio button click twice
                if (e.target.tagName === 'INPUT' || isHidden(e.target)) {
                    return;
                }
                _this.resetEffect(node);
                // Get wave color from target
                var waveColor = getComputedStyle(node).getPropertyValue('border-top-color') || // Firefox Compatible
                getComputedStyle(node).getPropertyValue('border-color') || getComputedStyle(node).getPropertyValue('background-color');
                _this.clickWaveTimeoutId = window.setTimeout(function () {
                    return _this.onClick(node, waveColor);
                }, 0);
                __WEBPACK_IMPORTED_MODULE_7__util_raf__["a" /* default */].cancel(_this.animationStartId);
                _this.animationStart = true;
                // Render to trigger transition event cost 3 frames. Let's delay 10 frames to reset this.
                _this.animationStartId = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7__util_raf__["a" /* default */])(function () {
                    _this.animationStart = false;
                }, 10);
            };
            node.addEventListener('click', onClick, true);
            return {
                cancel: function cancel() {
                    node.removeEventListener('click', onClick, true);
                }
            };
        };
        _this.onTransitionStart = function (e) {
            if (_this.destroy) return;
            var node = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5_react_dom__["findDOMNode"])(_this);
            if (!e || e.target !== node) {
                return;
            }
            if (!_this.animationStart) {
                _this.resetEffect(node);
            }
        };
        _this.onTransitionEnd = function (e) {
            if (!e || e.animationName !== 'fadeEffect') {
                return;
            }
            _this.resetEffect(e.target);
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass___default()(Wave, [{
        key: 'isNotGrey',
        value: function isNotGrey(color) {
            var match = (color || '').match(/rgba?$(\d*), (\d*), (\d*)(, [\.\d]*)?$/);
            if (match && match[1] && match[2] && match[3]) {
                return !(match[1] === match[2] && match[2] === match[3]);
            }
            return true;
        }
    }, {
        key: 'getAttributeName',
        value: function getAttributeName() {
            var insertExtraNode = this.props.insertExtraNode;

return insertExtraNode ? 'ant-click-animating' : 'ant-click-animating-without-extra-node';
        }
    }, {
        key: 'resetEffect',
        value: function resetEffect(node) {
            if (!node || node === this.extraNode || !(node instanceof Element)) {
                return;
            }
            var insertExtraNode = this.props.insertExtraNode;

return Wave;
}(__WEBPACK_IMPORTED_MODULE_4_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (Wave);
/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(1)))

/***/ }),
/* 345 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rc_checkbox__ = __webpack_require__(468);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_shallowequal__ = __webpack_require__(115);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_shallowequal___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_10_shallowequal__);

var Checkbox = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Checkbox, _React$Component);

function Checkbox() {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Checkbox);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Checkbox.__proto__ || Object.getPrototypeOf(Checkbox)).apply(this, arguments));

_this.saveCheckbox = function (node) {
            _this.rcCheckbox = node;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Checkbox, [{
        key: 'shouldComponentUpdate',
        value: function shouldComponentUpdate(nextProps, nextState, nextContext) {
            return !__WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.props, nextProps) || !__WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.state, nextState) || !__WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.context.checkboxGroup, nextContext.checkboxGroup);
        }
    }, {
        key: 'focus',
        value: function focus() {
            this.rcCheckbox.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.rcCheckbox.blur();
        }
    }, {
        key: 'render',
        value: function render() {
            var _classNames;

var props = this.props,
                context = this.context;

var prefixCls = props.prefixCls,
                className = props.className,
                children = props.children,
                indeterminate = props.indeterminate,
                style = props.style,
                onMouseEnter = props.onMouseEnter,
                onMouseLeave = props.onMouseLeave,
                restProps = __rest(props, ["prefixCls", "className", "children", "indeterminate", "style", "onMouseEnter", "onMouseLeave"]);

var checkboxGroup = context.checkboxGroup;

return Checkbox;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (Checkbox);

Checkbox.defaultProps = {
    prefixCls: 'ant-checkbox',
    indeterminate: false
};
Checkbox.contextTypes = {
    checkboxGroup: __WEBPACK_IMPORTED_MODULE_7_prop_types__["any"]
};

/***/ }),
/* 346 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

// Merge into a locale object
var locale = {
    lang: __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ placeholder: 'Select date', rangePlaceholder: ['Start date', 'End date'] }, __WEBPACK_IMPORTED_MODULE_1_rc_calendar_es_locale_en_US__["a" /* default */]),
    timePickerLocale: __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, __WEBPACK_IMPORTED_MODULE_2__time_picker_locale_en_US__["a" /* default */])
};
// All settings at:
// https://github.com/ant-design/ant-design/blob/master/components/date-picker/locale/example.json
/* harmony default export */ __webpack_exports__["a"] = (locale);

/***/ }),
/* 347 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(919);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);

/***/ }),
/* 348 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_omit_js__ = __webpack_require__(138);

function fixControlledValue(value) {
    if (typeof value === 'undefined' || value === null) {
        return '';
    }
    return value;
}

var Input = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Input, _React$Component);

function Input() {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Input);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Input.__proto__ || Object.getPrototypeOf(Input)).apply(this, arguments));

_this.handleKeyDown = function (e) {
            var _this$props = _this.props,
                onPressEnter = _this$props.onPressEnter,
                onKeyDown = _this$props.onKeyDown;

if (e.keyCode === 13 && onPressEnter) {
                onPressEnter(e);
            }
            if (onKeyDown) {
                onKeyDown(e);
            }
        };
        _this.saveInput = function (node) {
            _this.input = node;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Input, [{
        key: 'focus',
        value: function focus() {
            this.input.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.input.blur();
        }
    }, {
        key: 'select',
        value: function select() {
            this.input.select();
        }
    }, {
        key: 'getInputClassName',
        value: function getInputClassName() {
            var _classNames;

var _props = this.props,
                prefixCls = _props.prefixCls,
                size = _props.size,
                disabled = _props.disabled;

return __WEBPACK_IMPORTED_MODULE_8_classnames___default()(prefixCls, (_classNames = {}, __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-sm', size === 'small'), __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-lg', size === 'large'), __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-disabled', disabled), _classNames));
        }
    }, {
        key: 'renderLabeledInput',
        value: function renderLabeledInput(children) {
            var _classNames3;

var props = this.props;

if (!('prefix' in props || 'suffix' in props)) {
                return children;
            }
            var prefix = props.prefix ? __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                'span',
                { className: props.prefixCls + '-prefix' },
                props.prefix
            ) : null;
            var suffix = props.suffix ? __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                'span',
                { className: props.prefixCls + '-suffix' },
                props.suffix
            ) : null;
            var affixWrapperCls = __WEBPACK_IMPORTED_MODULE_8_classnames___default()(props.className, props.prefixCls + '-affix-wrapper', (_classNames4 = {}, __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames4, props.prefixCls + '-affix-wrapper-sm', props.size === 'small'), __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames4, props.prefixCls + '-affix-wrapper-lg', props.size === 'large'), _classNames4));
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                'span',
                { className: affixWrapperCls, style: props.style },
                prefix,
                __WEBPACK_IMPORTED_MODULE_6_react__["cloneElement"](children, { style: null, className: this.getInputClassName() }),
                suffix
            );
        }
    }, {
        key: 'renderInput',
        value: function renderInput() {
            var _props2 = this.props,
                value = _props2.value,
                className = _props2.className;
            // Fix https://fb.me/react-unknown-prop

return Input;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (Input);

Input.defaultProps = {
    prefixCls: 'ant-input',
    type: 'text',
    disabled: false
};
Input.propTypes = {
    type: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    id: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_7_prop_types__["string"], __WEBPACK_IMPORTED_MODULE_7_prop_types__["number"]]),
    size: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOf"](['small', 'default', 'large']),
    maxLength: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_7_prop_types__["string"], __WEBPACK_IMPORTED_MODULE_7_prop_types__["number"]]),
    disabled: __WEBPACK_IMPORTED_MODULE_7_prop_types__["bool"],
    value: __WEBPACK_IMPORTED_MODULE_7_prop_types__["any"],
    defaultValue: __WEBPACK_IMPORTED_MODULE_7_prop_types__["any"],
    className: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    addonBefore: __WEBPACK_IMPORTED_MODULE_7_prop_types__["node"],
    addonAfter: __WEBPACK_IMPORTED_MODULE_7_prop_types__["node"],
    prefixCls: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    onPressEnter: __WEBPACK_IMPORTED_MODULE_7_prop_types__["func"],
    onKeyDown: __WEBPACK_IMPORTED_MODULE_7_prop_types__["func"],
    onKeyUp: __WEBPACK_IMPORTED_MODULE_7_prop_types__["func"],
    onFocus: __WEBPACK_IMPORTED_MODULE_7_prop_types__["func"],
    onBlur: __WEBPACK_IMPORTED_MODULE_7_prop_types__["func"],
    prefix: __WEBPACK_IMPORTED_MODULE_7_prop_types__["node"],
    suffix: __WEBPACK_IMPORTED_MODULE_7_prop_types__["node"]
};

/***/ }),
/* 349 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var LocaleReceiver = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(LocaleReceiver, _React$Component);

function LocaleReceiver() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, LocaleReceiver);

return __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (LocaleReceiver.__proto__ || Object.getPrototypeOf(LocaleReceiver)).apply(this, arguments));
    }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(LocaleReceiver, [{
        key: 'getLocale',
        value: function getLocale() {
            var _props = this.props,
                componentName = _props.componentName,
                defaultLocale = _props.defaultLocale;

var locale = defaultLocale || __WEBPACK_IMPORTED_MODULE_7__default__["a" /* default */][componentName || 'global'];
            var antLocale = this.context.antLocale;

return LocaleReceiver;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (LocaleReceiver);

LocaleReceiver.defaultProps = {
    componentName: 'global'
};
LocaleReceiver.contextTypes = {
    antLocale: __WEBPACK_IMPORTED_MODULE_6_prop_types__["object"]
};

/***/ }),
/* 350 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rc_dialog__ = __webpack_require__(1137);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_rc_util_es_Dom_addEventListener__ = __webpack_require__(141);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__button__ = __webpack_require__(149);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__locale_provider_LocaleReceiver__ = __webpack_require__(349);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__locale__ = __webpack_require__(351);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__icon__ = __webpack_require__(52);

var mousePosition = void 0;
var mousePositionEventBinded = void 0;

var Modal = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Modal, _React$Component);

function Modal() {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Modal);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Modal.__proto__ || Object.getPrototypeOf(Modal)).apply(this, arguments));

_this.handleCancel = function (e) {
            var onCancel = _this.props.onCancel;
            if (onCancel) {
                onCancel(e);
            }
        };
        _this.handleOk = function (e) {
            var onOk = _this.props.onOk;
            if (onOk) {
                onOk(e);
            }
        };
        _this.renderFooter = function (locale) {
            var _this$props = _this.props,
                okText = _this$props.okText,
                okType = _this$props.okType,
                cancelText = _this$props.cancelText,
                confirmLoading = _this$props.confirmLoading;

return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                'div',
                null,
                __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                    __WEBPACK_IMPORTED_MODULE_11__button__["default"],
                    __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({ onClick: _this.handleCancel }, _this.props.cancelButtonProps),
                    cancelText || locale.cancelText
                ),
                __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                    __WEBPACK_IMPORTED_MODULE_11__button__["default"],
                    __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({ type: okType, loading: confirmLoading, onClick: _this.handleOk }, _this.props.okButtonProps),
                    okText || locale.okText
                )
            );
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Modal, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
            if (mousePositionEventBinded) {
                return;
            }
            // 只有点击事件支持从鼠标位置动画展开
            __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_10_rc_util_es_Dom_addEventListener__["a" /* default */])(document.documentElement, 'click', function (e) {
                mousePosition = {
                    x: e.pageX,
                    y: e.pageY
                };
                // 100ms 内发生过点击事件，则从点击位置动画展示
                // 否则直接 zoom 展示
                // 这样可以兼容非点击方式展开
                setTimeout(function () {
                    return mousePosition = null;
                }, 100);
            });
            mousePositionEventBinded = true;
        }
    }, {
        key: 'render',
        value: function render() {
            var _a = this.props,
                footer = _a.footer,
                visible = _a.visible,
                wrapClassName = _a.wrapClassName,
                centered = _a.centered,
                prefixCls = _a.prefixCls,
                restProps = __rest(_a, ["footer", "visible", "wrapClassName", "centered", "prefixCls"]);
            var defaultFooter = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                __WEBPACK_IMPORTED_MODULE_12__locale_provider_LocaleReceiver__["a" /* default */],
                { componentName: 'Modal', defaultLocale: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__locale__["a" /* getConfirmLocale */])() },
                this.renderFooter
            );
            var closeIcon = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](
                'span',
                { className: prefixCls + '-close-x' },
                __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_14__icon__["default"], { className: prefixCls + '-close-icon', type: 'close' })
            );
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_7_rc_dialog__["a" /* default */], __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, restProps, { prefixCls: prefixCls, wrapClassName: __WEBPACK_IMPORTED_MODULE_9_classnames___default()(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()({}, prefixCls + '-centered', !!centered), wrapClassName), footer: footer === undefined ? defaultFooter : footer, visible: visible, mousePosition: mousePosition, onClose: this.handleCancel, closeIcon: closeIcon }));
        }
    }]);

return Modal;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (Modal);

Modal.defaultProps = {
    prefixCls: 'ant-modal',
    width: 520,
    transitionName: 'zoom',
    maskTransitionName: 'fade',
    confirmLoading: false,
    visible: false,
    okType: 'primary',
    okButtonDisabled: false,
    cancelButtonDisabled: false
};
Modal.propTypes = {
    prefixCls: __WEBPACK_IMPORTED_MODULE_8_prop_types__["string"],
    onOk: __WEBPACK_IMPORTED_MODULE_8_prop_types__["func"],
    onCancel: __WEBPACK_IMPORTED_MODULE_8_prop_types__["func"],
    okText: __WEBPACK_IMPORTED_MODULE_8_prop_types__["node"],
    cancelText: __WEBPACK_IMPORTED_MODULE_8_prop_types__["node"],
    centered: __WEBPACK_IMPORTED_MODULE_8_prop_types__["bool"],
    width: __WEBPACK_IMPORTED_MODULE_8_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_8_prop_types__["number"], __WEBPACK_IMPORTED_MODULE_8_prop_types__["string"]]),
    confirmLoading: __WEBPACK_IMPORTED_MODULE_8_prop_types__["bool"],
    visible: __WEBPACK_IMPORTED_MODULE_8_prop_types__["bool"],
    align: __WEBPACK_IMPORTED_MODULE_8_prop_types__["object"],
    footer: __WEBPACK_IMPORTED_MODULE_8_prop_types__["node"],
    title: __WEBPACK_IMPORTED_MODULE_8_prop_types__["node"],
    closable: __WEBPACK_IMPORTED_MODULE_8_prop_types__["bool"]
};

/***/ }),
/* 351 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export changeConfirmLocale */
/* harmony export (immutable) */ __webpack_exports__["a"] = getConfirmLocale;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__locale_provider_default__ = __webpack_require__(207);

/***/ }),
/* 352 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
var locale = {
    placeholder: 'Select time'
};
/* harmony default export */ __webpack_exports__["a"] = (locale);

/***/ }),
/* 353 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var PresetBlock = __webpack_require__(635),
    store = __webpack_require__(11),
    isEqual = __webpack_require__(86),
    closeDrawer = __webpack_require__(2).closeDrawer,
    resetPreset = __webpack_require__(2).resetPreset,
    findDOMNode = __webpack_require__(7).findDOMNode,
    FlipMove = __webpack_require__(492),
    setPreset = __webpack_require__(2).setPreset,
    scrollRevealBE = __webpack_require__(375),
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker;

var PresetBlockWrapper = React.createClass({
	displayName: 'PresetBlockWrapper',

triggerReveal: false,
	lazyRevealObj: null,
	getInitialState: function getInitialState() {

return {
			active: false,
			activeIndex: -1
		};
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

if (!this.props.presetsList.size && nextProps.presetsList.size) {
			this.triggerReveal = true;
		}
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

return !(Immutable.is(this.props.sectionPath, nextProps.sectionPath) && isEqual(this.state, nextState) && Immutable.is(this.props.presetsList, nextProps.presetsList));
	},

_setActivePreset: function _setActivePreset(index, event) {
		if (-1 !== this.state.activeIndex) {
			store.dispatch(resetPreset(this.props.sectionPath, this.props.presetsList.getIn([this.state.activeIndex, 'content'])));
		}
		store.dispatch(setPreset(this.props.sectionPath, this.props.presetsList.getIn([index, 'content'])));
		if (!this.state.active) {
			this.triggerReveal = true;
			this.setState({
				active: true,
				activeIndex: index
			});
		} else if (this.state.activeIndex != index) {
			this.setState({
				activeIndex: index
			});
		}
	},

componentDidMount: function componentDidMount() {

var scrollParent = document.getElementsByClassName('tatsu-scroll-hide-middle-wrap')[0],
		    childArray = findDOMNode(this).children[1].children;
		this.lazyRevealObj = scrollRevealBE(childArray, scrollParent);
		this.lazyRevealObj.init();
	},

componentDidUpdate: function componentDidUpdate() {

if (this.triggerReveal) {

setTimeout(function () {
				this.lazyRevealObj.reveal();
			}.bind(this), 300);
			this.triggerReveal = false;
		}
	},

_cancelPreset: function _cancelPreset(event) {

store.dispatch(resetPreset(this.props.sectionPath, this.props.presetsList.getIn([this.state.activeIndex, 'content'])));
		this.setState({
			active: false,
			activeIndex: -1
		});
	},

_applyPreset: function _applyPreset(event) {

//handler to apply the preset
		store.dispatch(closeDrawer());
	},

render: function render() {

var sectionPresetsList = this.props.presetsList,
		    currentState = this.state;

return React.createElement(
			'div',
			{ className: 'tatsu-concepts-container', style: { top: currentState.active ? '-220px' : '0' } },
			React.createElement(
				'div',
				{ className: 'tatsu-concepts-title-wrapper' },
				'Concepts'
			),
			React.createElement(
				'div',
				{ className: 'tatsu-preset-container' },
				0 == sectionPresetsList.size ? 'Loading' : sectionPresetsList.map(function (sectionPreset, index) {
					var isActive = currentState.activeIndex == index;

return React.createElement(PresetBlock, { isActive: isActive, setActivePreset: this._setActivePreset, currentIndex: index, imageHeight: sectionPreset.get('height') || "110px", imageWidth: sectionPreset.get('width') || "210px", imageSource: sectionPreset.get('img') });
				}.bind(this))
			),
			React.createElement(
				FlipMove,
				{ enterAnimation: 'fade', leaveAnimation: 'fade' },
				this.state.active ? React.createElement(
					'div',
					{ className: 'tatsu-preset-apply-wrapper' },
					React.createElement(
						'div',
						{ onClick: this._cancelPreset, className: 'tatsu-cancel-preset' },
						'Cancel'
					),
					React.createElement(
						'div',
						{ onClick: this._applyPreset, className: 'tatsu-apply-preset' },
						'Apply'
					)
				) : null
			)
		);
	}

});
PresetBlockWrapper.propTypes = {

presetsList: listChecker,
	sectionPath: listChecker

};
module.exports = PresetBlockWrapper;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 354 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var Palettes = React.createClass({
    displayName: 'Palettes',

getInitialState: function getInitialState() {

return {
            selectedPalette: ''
        };
    },
    // Get the current Color Hub Palette
    getCurrentColorHubPalette: function getCurrentColorHubPalette(palettes) {
        var currentPaletteID = palettes.currentPalette;
        return palettes.allPalettes[currentPaletteID];
    },
    // Compute Gradient Value from Color Hub Data
    computeGradientforSwatchAndPalette: function computeGradientforSwatchAndPalette(colorHubData) {
        if ((typeof colorHubData === 'undefined' ? 'undefined' : _typeof(colorHubData)) !== 'object') {
            return colorHubData;
        } else {
            var colorValue = '',
                colorStops = Object.keys(colorHubData.colorPositions).length;

if (colorStops == 1) {
                colorValue = colorHubData.colorPositions[0];
            } else {
                colorValue = 'linear-gradient(';
                colorValue = colorValue + colorHubData.angle + 'deg';
                for (var position in colorHubData.colorPositions) {
                    colorValue = colorValue + ',' + colorHubData.colorPositions[position] + ' ' + position + '%';
                }
                colorValue = colorValue + ')';
            }
            return colorValue;
        }
    },

render: function render() {

module.exports = Palettes;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 355 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var getBookmark = __webpack_require__(32).getBookmark,
    moveToBookmark = __webpack_require__(32).moveToBookmark;

var Swatches = React.createClass({
    displayName: 'Swatches',

currentBookMark: null,

getInitialState: function getInitialState() {
        return {
            searchSwatch: ''
        };
    },

_handleBlur: function _handleBlur(event) {

setTimeout(function () {
            if (this.currentBookMark) {
                this.currentBookMark = null;
                this.props.resetState ? this.props.resetState() : null;
            }
        }.bind(this), 0);
    },

// Swatch Search 
    searchSwatches: function searchSwatches(event) {
        this.setState({
            searchSwatch: event.target.value
        });
        this.props.useOverride ? this.props.useOverride(false) : null;
    },
    // Convert RGB Color To HEX Value
    rgbToHex: function rgbToHex(rgbColor) {
        if ('#' == rgbColor.charAt(0)) {
            return rgbColor;
        } else {
            var rgbSplit = rgbColor.replace('rgba', '').replace('(', '').replace(')', '').split(',');
            return this.convertComponent(rgbSplit[0]) + '' + this.convertComponent(rgbSplit[1]) + '' + this.convertComponent(rgbSplit[2]);
        }
    },
    // Get Swatches from Prop
    getSwatchInfo: function getSwatchInfo(searchKey) {
        var swatchFromHub = this.props.colorHub.hasOwnProperty('swatches') ? this.props.colorHub.swatches : '',
            //default set of swatches
        swatchArray = [];
        searchKey = searchKey.toLowerCase();
        for (var swatch in swatchFromHub) {
            var swatchBG = {
                background: this.computeGradientforSwatchAndPalette(swatchFromHub[swatch].color)
            };
            if (swatchFromHub[swatch].label.toLowerCase().startsWith(searchKey) || typeof swatchFromHub[swatch].color === 'string' && searchKey.startsWith('#') && this.rgbToHex(swatchFromHub[swatch].color).toLowerCase().startsWith(searchKey)) {
                swatchArray.push({ key: swatch, label: swatchFromHub[swatch].label, color: swatchFromHub[swatch].color, style: swatchBG });
            }
        }
        return swatchArray;
    },
    _handleInputMouseDown: function _handleInputMouseDown(event) {
        event.stopPropagation();
        if (!this.props.isOverriden) {
            this.currentBookMark = this.props.activeEditorId ? getBookmark(this.props.activeEditorId) : null;
            this.props.useOverride ? this.props.useOverride(true) : null;
        }
    },
    // Compute Gradient Value from Color Hub Data
    computeGradientforSwatchAndPalette: function computeGradientforSwatchAndPalette(colorHubData) {
        if ((typeof colorHubData === 'undefined' ? 'undefined' : _typeof(colorHubData)) !== 'object') {
            return colorHubData;
        } else {
            var colorValue = '',
                colorStops = Object.keys(colorHubData.colorPositions).length;

render: function render() {

return React.createElement(
            'div',
            { className: 'be-swatch-wrap' },
            React.createElement('input', { type: 'text', className: 'swatch-search', name: 'Search Swatches', placeholder: 'Search', value: this.state.searchSwatch, onBlur: this._handleBlur, onMouseDown: this._handleInputMouseDown, onChange: this.searchSwatches }),
            this.getSwatchInfo(this.state.searchSwatch).map(function (item, index) {
                return React.createElement('div', { key: item.key, 'data-label': item.label, className: "single-swatch " + (this.props.selectedSwatch === item.key ? "show-selection" : "") + (!this.props.enableGradient && _typeof(item.color) === 'object' ? 'disbaled-swatch' : ''), style: item.style, onClick: !this.props.enableGradient && _typeof(item.color) === 'object' ? '' : this.props.swatchClick.bind(this, item) });
            }, this)
        );
    }
});

module.exports = Swatches;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 356 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _input = __webpack_require__(77);

var _input2 = _interopRequireDefault(_input);

var _icon = __webpack_require__(52);

var _icon2 = _interopRequireDefault(_icon);

var _modal = __webpack_require__(118);

var _modal2 = _interopRequireDefault(_modal);

var _autoComplete = __webpack_require__(600);

var _autoComplete2 = _interopRequireDefault(_autoComplete);

__webpack_require__(78);

__webpack_require__(347);

__webpack_require__(119);

__webpack_require__(601);

var _EditorHelpers = __webpack_require__(26);

__webpack_require__(902);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Option = _autoComplete2.default.Option,
    OptGroup = _autoComplete2.default.OptGroup;

function CustomFieldIcon() {
    return React.createElement(
        'svg',
        { viewBox: '64 64 896 896', focusable: 'false', 'class': '', 'data-icon': 'database', width: '1em', height: '1em', fill: 'currentColor', 'aria-hidden': 'true' },
        React.createElement('path', { d: 'M832 64H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V96c0-17.7-14.3-32-32-32zm-600 72h560v208H232V136zm560 480H232V408h560v208zm0 272H232V680h560v208zM304 240a40 40 0 1 0 80 0 40 40 0 1 0-80 0zm0 272a40 40 0 1 0 80 0 40 40 0 1 0-80 0zm0 272a40 40 0 1 0 80 0 40 40 0 1 0-80 0z' })
    );
}

function renderTitle(title) {
    return React.createElement(
        'span',
        { className: 'be-optgroup-title' },
        title
    );
}

var BeTextField = function (_React$Component) {
    _inherits(BeTextField, _React$Component);

function BeTextField(props) {
        _classCallCheck(this, BeTextField);

var _this = _possibleConstructorReturn(this, (BeTextField.__proto__ || Object.getPrototypeOf(BeTextField)).call(this, props));

_this.options = null;
        _this.optionsType = null;
        if (_this.props.isAjax) {
            _this.state = {
                value: ''
            };
        }
        _this.validateOptions = _this.validateOptions.bind(_this);
        _this.onChange = _this.onChange.bind(_this);
        _this.clearValue = _this.clearValue.bind(_this);
        return _this;
    }

_createClass(BeTextField, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            if ('string' == typeof this.props.value) {
                this.validateOptions();
                if (this.props.isAjax) {
                    this.setState({
                        value: this.props.value
                    });
                }
            }
        }
    }, {
        key: 'validateOptions',
        value: function validateOptions() {
            if ((0, _EditorHelpers.isValidDataStructure)(this.props.options) && (0, _EditorHelpers.validateValues)(this.props.options)) {
                this.options = this.props.options;
                if ((0, _EditorHelpers.isImmutable)(this.props.options)) {
                    this.optionsType = 'immutable';
                } else if ('[object Object]' == (0, _EditorHelpers.getObjectType)(this.props.options)) {
                    this.optionsType = 'object';
                }
            }
        }
    }, {
        key: 'onChange',
        value: function onChange(value) {
            //const { value } = e.target;
            if (this.props.isAjax) {
                this.setState({
                    value: value
                });
                (0, _EditorHelpers.debounce)(this.props.onChange, 700, value);
            } else {
                this.props.onChange(value);
            }
        }
    }, {
        key: 'iconOnClick',
        value: function iconOnClick() {
            if (!tatsuConfig.is_pro) {
                _modal2.default.confirm({
                    title: 'Tatsu Pro required!',
                    content: 'Upgrade to “Tatsu Pro” to enable Dynamic fields integration.',
                    iconType: 'info-circle',
                    className: 'tatsu-pro-upsell',
                    okText: 'Buy Tatsu Pro',
                    onOk: function onOk() {
                        window.open('https://tatsubuilder.com/', '_blank');
                    }
                });
            }
        }
    }, {
        key: 'clearValue',
        value: function clearValue() {
            if (this.props.isAjax) {
                this.setState({
                    value: ''
                });
                (0, _EditorHelpers.debounce)(this.props.onChange, 700, '');
            } else {
                this.props.onChange('');
            }
        }
    }, {
        key: 'render',
        value: function render() {
            var isDynamic = false;
            if (this.props.moduleOptions && 'undefined' !== this.props.moduleOptions && this.props.moduleName && 'undefined' !== this.props.moduleName) {
                isDynamic = this.props.moduleOptions.getIn([this.props.moduleName, 'is_dynamic']);
            }
            var dataSource = tatsuConfig.fields || [];
            var placeholder = this.options && ('immutable' == this.optionsType ? this.options.get('placeholder') : 'object' == this.optionsType ? this.options.placeholder : false);

return BeTextField;
}(React.Component);

exports.default = BeTextField;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 357 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var ModuleList = __webpack_require__(680),
    resetSelection = __webpack_require__(2).resetSelection,
    smartSearch = __webpack_require__(158),
    store = __webpack_require__(11);
__webpack_require__(912);
var ModuleListWrapper = React.createClass({
	displayName: 'ModuleListWrapper',

getInitialState: function getInitialState() {

return {
			filter: ''
		};
	},

changeHandler: function changeHandler(event) {

var value = event.target.value;
		this.setState({
			filter: value
		});
	},

componentDidMount: function componentDidMount() {

if (this.props.draggable) {
			store.dispatch(resetSelection());
		}
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
		result = !(Immutable.is(nextProps.moduleOptions, this.props.moduleOptions) && this.state.filter === nextState.filter);
		return result;
	},

filterCallBack: function filterCallBack(value, key) {

return smartSearch(value.get('title'), this.state.filter);
	},

filterModules: function filterModules() {

var currentFilter = this.state.filter,
		    completeModules = this.props.moduleOptions,
		    filteredModuleOptions;

if ('' === currentFilter) {
			filteredModuleOptions = completeModules;
		} else {
			filteredModuleOptions = completeModules.filter(this.filterCallBack);
		}
		return filteredModuleOptions;
	},

render: function render() {

var filter = this.state.filter,
		    filteredModuleOptions = this.filterModules(),
		    drawerMeta = this.props.drawerMeta || null;

return React.createElement(ModuleList, { builderMode: this.props.builderMode, draggable: this.props.draggable, drawerMeta: this.props.drawerMeta, filterText: filter, moduleOptions: filteredModuleOptions, changeHandler: this.changeHandler });
	}

});
module.exports = ModuleListWrapper;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 358 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, React, $) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _modal = __webpack_require__(118);

var _modal2 = _interopRequireDefault(_modal);

__webpack_require__(119);

var _tabs = __webpack_require__(361);

var _tabs2 = _interopRequireDefault(_tabs);

var _reducer = __webpack_require__(11);

var _reducer2 = _interopRequireDefault(_reducer);

__webpack_require__(913);

var _prebuildCollection = __webpack_require__(681);

var _prebuildCollection2 = _interopRequireDefault(_prebuildCollection);

var _actionCreator = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var defaultTemplateMap = Immutable.Map({
    prebuilt: Immutable.Map({
        sections: Immutable.List(),
        templates: Immutable.List()
    }),
    custom: Immutable.Map({
        sections: Immutable.List(),
        templates: Immutable.List()
    })
});
var TabPane = _tabs2.default.Panel;

var TemplatesModal = function (_React$Component) {
    _inherits(TemplatesModal, _React$Component);

function TemplatesModal(props) {
        _classCallCheck(this, TemplatesModal);

var _this = _possibleConstructorReturn(this, (TemplatesModal.__proto__ || Object.getPrototypeOf(TemplatesModal)).call(this, props));

_this.state = {
            template: '',
            templateType: '',
            collectionType: '',
            loading: false
        };
        _this.setSelectedTemplate = _this.setSelectedTemplate.bind(_this);
        _this.checkIfSelected = _this.checkIfSelected.bind(_this);
        _this.renderCustomCollection = _this.renderCustomCollection.bind(_this);
        _this.renderPrebuiltCollection = _this.renderPrebuiltCollection.bind(_this);
        _this.toggleLoading = _this.toggleLoading.bind(_this);
        _this.deleteTemplate = _this.deleteTemplate.bind(_this);
        _this.loadTemplate = _this.loadTemplate.bind(_this);
        return _this;
    }

_createClass(TemplatesModal, [{
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            if (this.props.visible && !nextProps.visible) {
                if ('' != this.state.template) {
                    this.setState({
                        template: '',
                        templateType: '',
                        collectionType: '',
                        loading: false
                    });
                }
            }
        }
    }, {
        key: 'loadTemplate',
        value: function loadTemplate() {
            this.props.toggleTemplatesModal();
            if ('preset' === this.props.type) {
                _reducer2.default.dispatch((0, _actionCreator.loadTemplateAsPreset)(this.state.template, this.state.templateType, this.state.collectionType, this.props.path));
            } else {
                _reducer2.default.dispatch((0, _actionCreator.loadTemplate)(this.state.template, this.state.templateType, this.state.collectionType));
            }
        }
    }, {
        key: 'componentDidMount',
        value: function componentDidMount() {
            if (!this.props.templates.get('initialLoad')) {
                $.ajax({
                    type: 'POST',
                    dataType: 'json',
                    url: tatsuConfig.ajaxurl,
                    data: {
                        action: 'tatsu_get_templates_list',
                        size: 'thumbnail',
                        nonce: tatsuConfig.nonce
                    },
                    beforeSend: function beforeSend(xhr) {
                        xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
                    }
                }).then(function (templatesObj) {
                    var templateMap = 'object' == (typeof templatesObj === 'undefined' ? 'undefined' : _typeof(templatesObj)) && 0 < Object.keys(templatesObj).length ? Immutable.fromJS(templatesObj) : defaultTemplateMap;
                    _reducer2.default.dispatch((0, _actionCreator.loadTemplateToState)(templateMap));
                });
            }
        }
    }, {
        key: 'setSelectedTemplate',
        value: function setSelectedTemplate(templateName, templateType, collectionType) {
            this.setState({
                template: templateName,
                templateType: templateType,
                collectionType: collectionType
            });
        }
    }, {
        key: 'checkIfSelected',
        value: function checkIfSelected(templateName, templateType, collectionType) {
            var _state = this.state,
                templateNameInState = _state.template,
                templateTypeInState = _state.templateType,
                collectionTypeInState = _state.collectionType;

return templateName == templateNameInState && templateType == templateTypeInState && collectionType == collectionTypeInState;
        }
    }, {
        key: 'renderPrebuiltCollection',
        value: function renderPrebuiltCollection(collection, collectionType) {
            return React.createElement(_prebuildCollection2.default, {
                key: collectionType,
                checkIfSelected: this.checkIfSelected,
                setSelectedTemplate: this.setSelectedTemplate,
                collectionType: collectionType,
                collection: collection,
                toggleLoading: this.toggleLoading
            });
        }
    }, {
        key: 'deleteTemplate',
        value: function deleteTemplate(name, type, e) {
            var _this2 = this;

e.stopPropagation();
            if (!this.state.loading) {
                this.toggleLoading();
                $.ajax({
                    type: 'POST',
                    url: tatsuConfig.ajaxurl,
                    data: {
                        action: 'tatsu_delete_template',
                        name: name,
                        type: type,
                        nonce: tatsuConfig.nonce
                    },
                    beforeSend: function beforeSend(xhr) {
                        xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
                    }
                }).then(function (data) {
                    if ('false' === data) {
                        _this2.props.toggleTemplatesModal();
                        _reducer2.default.dispatch((0, _actionCreator.sendMessage)('Unable to Delete Template!', 'error'));
                    } else {
                        _reducer2.default.dispatch({ type: 'DELETE_TEMPLATE', name: name, templateType: type });
                        _this2.toggleLoading();
                    }
                });
            }
        }
    }, {
        key: 'renderCustomCollection',
        value: function renderCustomCollection(collection, collectionType) {
            var _this3 = this;

return React.createElement(
                'div',
                { className: 'tatsu-templates-collection-content' },
                React.createElement(
                    'div',
                    { className: 'tatsu-templates-collection-content-inner' },
                    collection.size ? React.createElement(
                        'div',
                        { className: 'tatsu-templates-collection-custom-content-wrap' },
                        React.createElement(
                            'div',
                            { className: 'tatsu-templates-collection-custom-element-header' },
                            React.createElement(
                                'div',
                                { className: 'tatsu-templates-header-title' },
                                'Name'
                            ),
                            React.createElement(
                                'div',
                                { className: 'tatsu-templates-header-created-by' },
                                'Created By'
                            ),
                            React.createElement(
                                'div',
                                { className: 'tatsu-templates-header-creation-date' },
                                'Date'
                            ),
                            React.createElement(
                                'div',
                                { className: 'tatsu-templates-header-preview' },
                                'Actions'
                            )
                        ),
                        React.createElement(
                            'div',
                            { className: 'tatsu-templates-collection-custom-content' },
                            Immutable.List.isList(collection) && collection.map(function (curCollection) {
                                return React.createElement(
                                    'div',
                                    { onClick: _this3.setSelectedTemplate.bind(null, curCollection.get('name'), 'custom', collectionType), className: "tatsu-templates-collection-custom-element" + (_this3.checkIfSelected(curCollection.get('name'), 'custom', collectionType) ? ' active' : '') },
                                    React.createElement(
                                        'div',
                                        { className: 'tatsu-templates-collection-custom-element-title' },
                                        curCollection.get('title')
                                    ),
                                    React.createElement(
                                        'div',
                                        { className: 'tatsu-templates-collection-custom-element-created-by' },
                                        curCollection.get('created_by') || '-'
                                    ),
                                    React.createElement(
                                        'div',
                                        { className: 'tatsu-templates-collection-custom-element-creation-date' },
                                        curCollection.get('created_at') || '-'
                                    ),
                                    React.createElement(
                                        'div',
                                        { className: 'tatsu-templates-collection-custom-element-delete' },
                                        React.createElement(
                                            'span',
                                            { onClick: _this3.deleteTemplate.bind(null, curCollection.get('name'), collectionType), className: 'tatsu-templates-collection-custom-element-delete-inner' },
                                            'Delete'
                                        )
                                    )
                                );
                            })
                        )
                    ) : React.createElement(
                        'div',
                        { className: 'tatsu-templates-collection-empty' },
                        'No templates found.'
                    )
                )
            );
        }
    }, {
        key: 'renderStructure',
        value: function renderStructure(templates) {
            return React.createElement(
                _tabs2.default,
                { className: 'tatsu-template-tabs' },
                templates.getIn(['prebuilt', 'sections']).size ? React.createElement(
                    TabPane,
                    { title: 'Sections' },
                    this.renderPrebuiltCollection(templates.getIn(['prebuilt', 'sections']), 'sections')
                ) : null,
                templates.getIn(['prebuilt', 'templates']).size ? React.createElement(
                    TabPane,
                    { title: 'Pages' },
                    this.renderPrebuiltCollection(templates.getIn(['prebuilt', 'templates']), 'templates')
                ) : null,
                React.createElement(
                    TabPane,
                    { title: 'Saved Templates' },
                    React.createElement(
                        _tabs2.default,
                        { className: 'tatsu-custom-template-tabs' },
                        React.createElement(
                            TabPane,
                            { title: 'Sections' },
                            this.renderCustomCollection(templates.getIn(['custom', 'sections']), 'sections')
                        ),
                        React.createElement(
                            TabPane,
                            { title: 'Pages' },
                            this.renderCustomCollection(templates.getIn(['custom', 'templates']), 'templates')
                        )
                    )
                )
            );
        }
    }, {
        key: 'toggleLoading',
        value: function toggleLoading() {
            var curLoading = this.state.loading;
            this.setState({
                loading: !curLoading
            });
        }
    }, {
        key: 'render',
        value: function render() {
            var loading = this.state.loading;

return React.createElement(
                _modal2.default,
                {
                    title: 'Templates',
                    className: 'tatsu-templates-modal',
                    visible: this.props.visible,
                    bodyStyle: { maxHeight: '700px', overflow: 'auto' },
                    confirmLoading: loading,
                    width: 1200,
                    onOk: this.loadTemplate,
                    okText: 'Load Template',
                    onCancel: this.props.toggleTemplatesModal,
                    cancelText: 'Cancel'
                },
                React.createElement(
                    'div',
                    { className: 'tatsu-templates-modal-inner' },
                    this.props.templates.get('initialLoad') ? this.renderStructure(this.props.templates) : 'Loading Templates'
                )
            );
        }
    }]);

return TemplatesModal;
}(React.Component);

exports.default = TemplatesModal;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 359 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var HeaderRow = __webpack_require__(224),
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    Immutable = __webpack_require__(3);
var headerRows = React.createClass({
    displayName: 'headerRows',

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

render: function render() {
        var children = this.props.pageContent.get('inner'),
            moduleOptions = this.props.moduleOptions || Immutable.Map();

return React.createElement(
            'div',
            null,
            children.map(function (headerRow) {
                var headerRowPath = Immutable.List();
                headerRowPath = headerRowPath.push(children.indexOf(headerRow));
                return React.createElement(HeaderRow, { builderMode: this.props.builderMode, key: headerRow.get('id'), pathFromSelectionState: this.props.pathFromSelectionState, dropEffect: this.props.dropEffect, targetDisplay: this.props.targetDisplay, path: headerRowPath, headerRow: headerRow, moduleOptions: moduleOptions });
            }.bind(this))
        );
    }

});
module.exports = headerRows;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 360 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _menu = __webpack_require__(91);

var _menu2 = _interopRequireDefault(_menu);

__webpack_require__(92);

var _menuItem = __webpack_require__(227);

var _menuItem2 = _interopRequireDefault(_menuItem);

var _menuGroup = __webpack_require__(226);

var _menuGroup2 = _interopRequireDefault(_menuGroup);

var _EditorHelpers = __webpack_require__(26);

__webpack_require__(409);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var BeMenu = function BeMenu(props) {
    var children = props.children;

BeMenu.BeMenuItem = _menuItem2.default;
BeMenu.BeMenuGroup = _menuGroup2.default;
exports.default = BeMenu;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 361 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _tooltip = __webpack_require__(58);

var _tooltip2 = _interopRequireDefault(_tooltip);

__webpack_require__(59);

__webpack_require__(914);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Tabs = function (_React$Component) {
    _inherits(Tabs, _React$Component);

function Tabs(props) {
        _classCallCheck(this, Tabs);

var _this = _possibleConstructorReturn(this, (Tabs.__proto__ || Object.getPrototypeOf(Tabs)).call(this, props));

_this.state = {
            tabActive: _this.props.tabActive || _this.getDefaultTabActive()
        };
        return _this;
    }

_createClass(Tabs, [{
        key: 'getDefaultTabActive',
        value: function getDefaultTabActive() {
            var defaultActive = -1;
            React.Children.forEach(this.props.children, function (panel, index) {
                if (panel && -1 === defaultActive) {
                    defaultActive = index + 1;
                }
            });
            return defaultActive;
        }
    }, {
        key: 'render',
        value: function render() {
            var className = 'tatsu-tabs ' + (this.props.className || '');
            return React.createElement(
                'div',
                { className: className },
                this._getMenuItems(),
                this._getSelectedPanel()
            );
        }
    }, {
        key: 'setActive',
        value: function setActive(index, e) {
            e.preventDefault();

this.setState({ tabActive: index });
        }
    }, {
        key: 'parseIcon',
        value: function parseIcon(icon) {
            if ('string' == typeof icon) {
                return React.createElement(
                    'svg',
                    { className: 'tatsu-tab-icon' },
                    React.createElement('use', { xlinkHref: icon })
                );
            } else {
                return icon;
            }
        }
    }, {
        key: '_getMenuItems',
        value: function _getMenuItems() {
            var _this2 = this;

if (!this.props.children) {
                throw new Error('Tabs must contain at least one Tabs.Panel');
            }
            var style = this.props.style || 'style1',
                menuItems = React.Children.map(this.props.children, function (panel, index) {
                if (panel) {
                    var title = panel.props.title,
                        icon = panel.props.icon,
                        classes = 'tatsu-tabs-menu-item ' + (_this2.state.tabActive === index + 1 ? 'is-active' : '');
                    return React.createElement(
                        'li',
                        { key: index, className: classes, onClick: _this2.setActive.bind(_this2, index + 1) },
                        'style1' === style ? React.createElement(
                            'div',
                            { className: 'tatsu-tabs-menu-item-inner' },
                            icon && React.createElement(
                                'div',
                                { className: 'tatsu-tabs-menu-item-icon' },
                                _this2.parseIcon(icon)
                            ),
                            React.createElement(
                                'div',
                                { className: 'tatsu-tabs-menu-item-title' },
                                title
                            )
                        ) : React.createElement(
                            _tooltip2.default,
                            { title: title },
                            React.createElement(
                                'div',
                                { className: 'tatsu-tabs-menu-item-inner' },
                                icon && React.createElement(
                                    'div',
                                    { className: 'tatsu-tabs-menu-item-icon' },
                                    _this2.parseIcon(icon)
                                )
                            )
                        )
                    );
                } else {
                    return panel;
                }
            });

return React.createElement(
                'nav',
                { className: 'tatsu-tabs-navigation ' + ('tatsu-tabs-navigation-' + style) },
                React.createElement(
                    'ul',
                    { className: 'tatsu-tabs-menu ' + ('tatsu-tabs-menu-cols-' + React.Children.count(this.props.children)) },
                    menuItems
                )
            );
        }
    }, {
        key: '_getSelectedPanel',
        value: function _getSelectedPanel() {
            var index = this.state.tabActive - 1;
            return Immutable.List.isList(this.props.children) || '[object Array]' == {}.toString.call(this.props.children) ? this.props.children.map(function (panel, panelIndex) {
                return panel ? React.createElement(
                    'article',
                    { style: { display: panelIndex === index ? 'block' : 'none' }, className: 'tatsu-tab-panel ' + panel.props.classes },
                    panel
                ) : panel;
            }) : React.createElement(
                'article',
                { className: 'tatsu-tab-panel' },
                this.props.children
            );
        }
    }]);

return Tabs;
}(React.Component);

Tabs.Panel = function (props) {
    return React.createElement(
        'div',
        null,
        props.children
    );
};

exports.default = Tabs;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 362 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports.homeConstant = "To start off add a section, click on it, view it's rows and columns. Click on the three dots to edit, delete or duplicate a section or simply drag and drop to rearrage them ";
module.exports.editorConstant = "Click on a Module on the Right Panel to start editing it";
module.exports.columnConstant = "Drag & Drop to rearrange the columns or click in it to add modules";
module.exports.columnSwitchConstant = "Switch Columns";
module.exports.columnLayoutConstant = "Column Layout";
module.exports.moduleListDraggable = "Drag and Drop a module to add it";
module.exports.moduleListClickable = "Click on a module to add it";
module.exports.miscellaneous = "Multiple modules of different types have been selected. You can perform actions like Drag & Drop, Cut , Copy & Paste on them";
module.exports.similar = "Multiple modules of same type selected, changing properties will affect all of the selected modules";

/***/ }),
/* 363 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var moduleObj = __webpack_require__(159);

module.exports = function addRow(moduleOptions) {

var newRowDefn = new moduleObj(),
		    newRow = newRowDefn.getModuleMap('tatsu_row', moduleOptions);

var newColumnDefn = new moduleObj(),
		    newColumn = newColumnDefn.getModuleMap('tatsu_column', moduleOptions);

newRow = newRow.setIn(['inner', 0], newColumn);
		return newRow;
};

/***/ }),
/* 364 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function (moduleOptions) {
    if (!Immutable.Map.isMap(moduleOptions)) {
        return Immutable.Map();
    }
    return moduleOptions.map(function (options, moduleName) {
        var attNameList,
            groupAtts = options.get('group_atts'),
            title = 'Layout';
        if (['tatsu_row', 'tatsu_inner_row', 'tatsu_header_row'].indexOf(moduleName) === -1 && 'multi' !== options.get('type')) {
            return options;
        }

if (['tatsu_row', 'tatsu_inner_row', 'tatsu_header_row'].indexOf(moduleName) === -1 && 'multi' === options.get('type')) {
            title = moduleOptions.getIn([options.get('child_module'), 'title']) + 's';
        }
        if (Immutable.List.isList(groupAtts) && 'tabs' === groupAtts.getIn([0, 'type'])) {
            return options.setIn(['group_atts', 0, 'group'], options.getIn(['group_atts', 0, 'group']).insert(0, Immutable.Map({
                type: 'tab',
                title: title,
                group: ['tatsu_builtin_layout']
            })));
        } else {
            attNameList = options.get('atts').map(function (att) {
                return att.get('att_name');
            });
            return options.set('group_atts', Immutable.fromJS([{
                'type': 'tabs',
                'style': 'style1',
                'group': [{
                    type: 'tab',
                    title: title,
                    group: ['tatsu_builtin_layout']
                }, {
                    type: 'tab',
                    title: 'Style',
                    group: attNameList
                }]
            }]));
        }
    });
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 365 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function checkConditionalAtts(condition, moduleAttributes, attName, moduleName) {
    if (Immutable.List.isList(condition)) {
        var controllerName = condition.get(0),
            conditionValue = condition.get(2),
            conditionOperator = condition.get(1),
            controllerValue = moduleAttributes.get(controllerName),
            parsedConditionalValue,
            output;
        switch (conditionOperator) {
            case '!=':
                output = controllerValue != conditionValue;
                break;

case '==':
            case '=':
                output = controllerValue == conditionValue;
                break;

case '>':
                parsedConditionalValue = Number(conditionValue);
                if (!isNaN(parsedConditionalValue)) {
                    output = controllerValue > parsedConditionalValue;
                } else {
                    output = false;
                }
                break;

case '<':
                parsedConditionalValue = Number(conditionValue);
                if (!isNaN(parsedConditionalValue)) {
                    output = controllerValue < parsedConditionalValue;
                } else {
                    output = false;
                }
                break;

case '<=':
                parsedConditionalValue = Number(conditionValue);
                if (!isNaN(parsedConditionalValue)) {
                    output = controllerValue <= parsedConditionalValue;
                } else {
                    output = false;
                }
                break;

case '>=':
                parsedConditionalValue = Number(conditionValue);
                if (!isNaN(parsedConditionalValue)) {
                    output = controllerValue >= parsedConditionalValue;
                } else {
                    output = false;
                }
                break;

default:
                console.log('Invalid condition. Check the module option config of ' + attName + ' in module ' + moduleName);
                output = false;
                break;
        }
        return output;
    } else if (Immutable.Map.isMap(condition) && condition.has('condition')) {
        var relation = condition.get('relation') || 'and',
            conditions = condition.get('condition');
        if ('and' == relation) {
            return conditions.every(function (condition) {
                return checkConditionalAtts(condition, moduleAttributes, attName, moduleName);
            });
        } else if ('or' == relation) {
            return conditions.some(function (condition) {
                return checkConditionalAtts(condition, moduleAttributes, attName, moduleName);
            });
        } else {
            console.log('Invalid relation. Check the module option config of ' + attName + ' in module ' + moduleName);
        }
    } else {
        console.log('Invalid Conditional Rendering. Check the module option config of ' + attName + ' in module ' + moduleName);
        return;
    }
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 366 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
//https://stackoverflow.com/questions/44240838/why-cant-object-literal-call-tostring-method-like-tostring-cause-error
var getObjectType = function getObjectType(obj) {
  return {}.toString.call(obj);
};
exports.default = getObjectType;

/***/ }),
/* 367 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = getBuilderMode;
function getBuilderMode() {
    var queryString = new URLSearchParams(window.location.search);
    if ('undefined' != typeof tatsuConfig && tatsuConfig.hasOwnProperty('mode')) {
        switch (tatsuConfig.mode) {
            case 'tatsu-header-builder':
                return 'header_builder';
            case 'tatsu-footer-builder':
                return 'footer_builder';
            case 'tatsu-page-builder':
                return 'page_builder';
            case 'tatsu-global-section':
                return 'global_section_builder';
        }
    } else if (queryString.has('action')) {
        switch (queryString.get('action')) {
            case 'tatsu-header':
                return 'header_builder';
            case 'tatsu-footer':
                return 'footer_builder';
            case 'tatsu':
                return 'page_builder';
            case 'tatsu-global':
                return 'global_section_builder';
        }
    } else if (queryString.has('tatsu-header')) {
        return 'header_builder';
    } else if (queryString.has('tatsu-footer')) {
        return 'footer_builder';
    } else if (queryString.has('tatsu-global')) {
        return 'global_section_builder';
    } else {
        return 'page_builder';
    }
}

/***/ }),
/* 368 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

/***/ }),
/* 369 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function getScrollDistance(node) {

var distance = 0;
    while (null != node && node.offsetParent) {
        distance = distance + node.offsetTop;
        node = node.offsetParent;
    }
    return distance;
};

/***/ }),
/* 370 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function getShortcode(module) {

shortcode = shortcode + getShortcode(child);
                });
            }
            shortcode = shortcode + '[/' + tag + ']';
        }
    }
    return shortcode;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 371 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function (str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return true;
};

/***/ }),
/* 372 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

// Function can be used to modify the Default Atts of any Module

module.exports = function (newModule, moduleType, triggerPoint) {

//Modify Header Column Alignment for Last Column of the Row
    if (moduleType === 'tatsu_header_column') {
        var headerColumns = newModule,
            numberOfColumns = headerColumns.size;

headerColumns = headerColumns.map(function (column, index) {
            if (index === numberOfColumns - 1 && numberOfColumns != 1) {
                column = column.setIn(['atts', 'horizontal_alignment'], Immutable.Map({ 'd': 'flex-end', 'l': 'flex-end', 't': 'flex-end', 'm': 'flex-end' }));
            }
            if (triggerPoint === 'new_module') {
                if (index === numberOfColumns - 1 && numberOfColumns != 1) {
                    column = column.setIn(['atts', 'column_width'], Immutable.Map({ 'd': 75, 'l': 75, 't': 75, 'm': 75 }));
                }
                if (index === 0) {
                    column = column.setIn(['atts', 'column_width'], Immutable.Map({ 'd': 25, 'l': 25, 't': 25, 'm': 25 }));
                }
            }
            return column;
        });
        newModule = headerColumns;
    }
    //Modify Margins for Modules added within Header Sidebar
    if (moduleType === 'header_sidebar_module' && newModule.get('name') !== 'tatsu_icon') {
        if (newModule.hasIn(['atts', 'margin', 'd'])) {
            newModule = newModule.setIn(['atts', 'margin', 'd'], '0px 0px 20px 0px');
        } else {
            newModule = newModule.setIn(['atts', 'margin'], '0px 0px 20px 0px');
        }
    }

return newModule;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 373 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var unescapeContent = __webpack_require__(378);
module.exports = function addDefaultValue(moduleData, moduleOptions) {

if (Immutable.Map.isMap(oldValue)) {
				if (!Immutable.Map.isMap(newValue)) {
					return oldValue.set('d', newValue);
				}
				return oldValue.merge(newValue);
			}
			return newValue;
		}, moduleAtts);
		mergedAtts = mergedAtts.map(function (attValue, attKey) {

if (moduleDefaultAtts.has(attKey)) {
				if ('string' != typeof attValue && 'number' != typeof attValue && !Immutable.Map.isMap(attValue)) {
					var correspondingAttFromModuleOptions = moduleDefaultAtts.get(attKey);
					if ('string' == typeof correspondingAttFromModuleOptions) {
						return unescapeContent(correspondingAttFromModuleOptions);
					} else if (Immutable.Map.isMap(correspondingAttFromModuleOptions)) {
						return correspondingAttFromModuleOptions.map(function (attValue, attName) {

if ('string' == typeof attValue) {
								return unescapeContent(attValue);
							}
							return attValue;
						});
					} else {
						return correspondingAttFromModuleOptions;
					}
				} else if (Immutable.Map.isMap(attValue)) {
					return attValue.map(function (attValue, attKey) {

if ('string' == typeof attValue) {
							return unescapeContent(attValue);
						}
						return attValue;
					});
				} else {
					return unescapeContent(attValue);
				}
			} else {
				return attValue;
			}
		});
		module = module.set('atts', mergedAtts);
	}
	for (var index = 0, length = children.size; index < length; index++) {
		currentChild = module.getIn(['inner', index]);
		currentChild = addDefaultValue(currentChild, moduleOptions);
		module = module.setIn(['inner', index], currentChild);
	}
	return module;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 374 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var shortid = __webpack_require__(116),
    getModuleKeyPath = __webpack_require__(39);

module.exports = function changeUuid(module) {
	var initialPath = Immutable.List(),
	    revisedPath,

// newUUID = uuid.v4(),
	newUUID = shortid.generate(),
	    module = module.set('id', newUUID),
	    children = module.get('inner'),
	    childrenCount = 'undefined' != typeof children ? children.size : 0,
	    index;
	if (module.get('atts').has('key')) {
		module = module.setIn(['atts', 'key'], newUUID);
	}
	for (index = 0; index < childrenCount; index++) {
		revisedPath = initialPath.push(index);
		var keyPath = getModuleKeyPath(revisedPath, '', ''),
		    childModule = module.getIn(keyPath);
		module = module.setIn(keyPath, changeUuid(childModule));
	}
	return module;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 375 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function (childArray, scrollParent) {

var revealedTill = 0,
	    checkIfElementIsVisible = function checkIfElementIsVisible(element) {

return element.getBoundingClientRect().top < scrollParent.getBoundingClientRect().bottom;
	},
	    reveal = function reveal() {
		if (revealedTill < childArray.length) {
			var child = childArray[revealedTill],
			    imageNode;
			while (child) {
				if (checkIfElementIsVisible(child)) {
					imageNode = child.children[1];
					imageNode.addEventListener('load', function (event) {

event.target.previousSibling.style.display = 'none';
					});
					imageNode.setAttribute('src', imageNode.getAttribute('data-img-source'));
					revealedTill++;
					child = child.nextElementSibling;
				} else {
					break;
				}
			}
		}
	};
	return {
		init: function init() {

reveal();
			scrollParent.addEventListener('scroll', function (event) {

reveal();
			});
		},
		reveal: reveal
	};
};

/***/ }),
/* 376 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

module.exports = function (filterText, value, delimeter) {
    delimeter = delimeter || ' ';
    value = value.split(' ');
    var result = [];
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

try {
        for (var _iterator = value[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var val = _step.value;

val = val.toLowerCase();
            filterText = filterText.toLowerCase();
            if (val.startsWith(filterText)) {
                val = React.createElement(
                    'span',
                    null,
                    React.createElement(
                        'span',
                        { className: 'filtered-text' },
                        filterText
                    ),
                    val.replace(filterText, ''),
                    ' '
                );
            }
            result.push(val);
            result.push(' ');
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally {
        try {
            if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
            }
        } finally {
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }

return result;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 377 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var modifyAttFormat = __webpack_require__(718);

module.exports = function stripOutputBeforeSave(module, moduleOptions) {

var children = module.get('inner'),
        currentAtts = module.get('atts'),
        childrenCount = 'undefined' != typeof children ? children.size : 0,
        index,
        currentModule = module.get('name'),
        attsFromModuleOptions = moduleOptions.getIn([currentModule, 'atts']),
        currentModuleOption,
        currentAttValue;

if (null != currentAtts) {

// Add Module ID as KEY in atts
        if (!currentAtts.has('key') || currentAtts.has('key') && currentAtts.get('key') == '') {
            currentAtts = currentAtts.set('key', module.get('id'));
        }
        //Modify Att Value before Saving
        currentAtts = modifyAttFormat(currentAtts, attsFromModuleOptions);
        module = module.set('atts', currentAtts);
    }
    if (module.has('shortcode_output') && 'string' == typeof module.get('shortcode_output') && '' != module.get('shortcode_output')) {
        module = module.set('shortcode_output', '');
    }
    if (module.has('meta')) {
        module = module.delete('meta');
    }
    for (index = 0; index < childrenCount; index++) {
        var childModule = children.get(index);
        module = module.setIn(['inner', index], stripOutputBeforeSave(childModule, moduleOptions));
    }
    return module;
};

/***/ }),
/* 378 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function decodeHtml(html) {

var txt = document.createElement("textarea");
    txt.innerHTML = html;
    return txt.value;
};

/***/ }),
/* 379 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var Immutable = __webpack_require__(3);

var initialStateData = Immutable.Map({
  tatsu_page_content: Immutable.Map({
    inner: Immutable.List(),
    builderLayout: 'list',
    name: 'HOME',
    title: 'HOME',
    childModule: 'section'
  }),
  tatsu_module_options: Immutable.Map({
    section: Immutable.Map({
      icon: '',
      is_js_dependant: false,
      childModule: 'row',
      type: 'core',
      atts: Immutable.OrderedMap({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: 'rgba(118,123,125,0.5)',
          tooltip: 'Background Color of the Section'
        }),
        bg_image: Immutable.Map({
          type: 'singleimagepicker',
          label: 'Background Image',
          defaultValue: '',
          tooltip: 'Choose a Background image'
        }),
        padding: Immutable.Map({
          type: 'inputgroup',
          label: 'Padding',
          options: {},
          defaultValue: '90px 0px 90px 0px',
          tooltip: 'Padding of the Section'
        }),
        textalignment: Immutable.Map({
          type: 'buttongroup',
          label: 'Text Align',
          options: {},
          defaultValue: 'left',
          tooltip: 'text alignment of elements within a section'
        }),
        fullscreensection: Immutable.Map({
          type: 'switch',
          label: 'Enable Full Screen Section',
          defaultValue: false,
          tooltip: 'Used to enable Full Screen section'
        }),
        tatsueditor: Immutable.Map({
          type: 'editor',
          label: 'Content Editor',
          options: {},
          defaultValue: '',
          tooltip: 'Default wordpress Editor'
        }),
        categories: Immutable.Map({
          type: 'groupedcheckbox',
          label: 'Portfolio Categories',
          defaultValue: '',
          tooltip: 'Select the portfolio categories to be displayed'
        }),
        backgroundrepeat: Immutable.Map({
          type: 'select',
          label: 'Background Repeat',
          options: {
            repeat: 'repeat',
            repeatx: 'repeat-x',
            four: 'four',
            repeaty: 'repeat-y',
            norepeat: 'no-repeat'
          },
          defaultValue: '',
          tooltip: 'Select the background repeat property'
        }),

sectionoverlayopacity: Immutable.Map({
          type: 'slider',
          label: 'Section Overlay Opacity',
          defaultValue: '50',
          tooltip: 'Used to select the sections Overlay opacity'
        }),
        sectionid: Immutable.Map({
          type: 'text',
          label: 'Section Id',
          defaultValue: '',
          tooltip: 'Use this to add a id to this section'
        }),
        sectionclass: Immutable.Map({
          type: 'text',
          label: 'Section Class',
          defaultValue: '',
          tooltip: 'Use this to add a class to this section'
        })
      })
    }),
    row: Immutable.Map({
      icon: '',
      is_js_dependant: false,
      childModule: 'column',
      type: 'core',
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#f2f5f8',
          tooltip: 'Background Color of the Section'
        }),
        no_wrap: Immutable.Map({
          type: 'switch',
          label: 'No Wrap',
          options: {},
          defaultValue: '0',
          tooltip: 'Enable Full Width Row'
        })
      })
    }),
    column: Immutable.Map({
      icon: '',
      is_js_dependant: false,
      childModule: 'module',
      type: 'core',
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#ffffff',
          tooltip: 'Background Color of the Column'
        })
      })
    }),
    tatsuplaceholder: Immutable.Map({
      name: 'tatsuplaceholder',
      icon: '',
      is_js_dependant: false,
      childModule: '',
      type: 'placeholder',
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#f2f5f8',
          tooltip: 'Background Color of the Section'
        })
      })
    }),
    title: Immutable.Map({
      name: 'tatsu_title',
      icon: 'Title',
      type: 'single',
      childModule: '',
      isBuiltIn: true,
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#f2f5f8',
          tooltip: 'Background Color of the Section'
        })
      }),
      content: ''
    }),
    button: Immutable.Map({
      name: 'button',
      icon: 'touch_app',
      type: 'single',
      childModule: '',
      isBuiltIn: true,
      atts: '',
      content: ''
    }),
    calltoaction: Immutable.Map({
      name: 'calltoaction',
      icon: 'thumb_up',
      type: 'single',
      childModule: '',
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#f2f5f8',
          tooltip: 'Background Color of the Section'
        })
      }),
      content: ''
    }),
    animated_numbers: Immutable.Map({
      name: 'animated_numbers',
      icon: 'forward_10',
      type: 'single',
      isBuiltIn: true,
      childModule: '',
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#f2f5f8',
          tooltip: 'Background Color of the Section'
        })
      }),
      content: ''
    }),
    portfolio: Immutable.Map({
      name: 'portfolio',
      icon: 'view_carousel',
      type: 'single',
      childModule: '',
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#f2f5f8',
          tooltip: 'Background Color of the Section'
        })
      }),
      content: ''
    }),
    services: Immutable.Map({
      name: 'services',
      icon: 'record_voice_over',
      type: 'multi',
      childModule: 'service',
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#f2f5f8',
          tooltip: 'Background Color of the Section'
        })
      }),
      content: ''
    }),
    service: Immutable.Map({
      name: 'service',
      icon: '',
      type: 'single',
      childModule: '',
      atts: Immutable.Map({
        bg_color: Immutable.Map({
          type: 'colorpicker',
          label: 'Background Color',
          options: {},
          defaultValue: '#f2f5f8',
          tooltip: 'Background Color of the Section'
        })
      })
    }),
    text: Immutable.Map({
      name: 'tatsu_text',
      icon: 'Title',
      type: 'single',
      isBuiltIn: true,
      childModule: '',
      atts: ''
    })

})
});

module.exports = initialStateData;

/***/ }),
/* 380 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateIdentifierId, generateVisibilityClasses) {

var mapChecker = __webpack_require__(16).mapChecker,
    findDOMNode = __webpack_require__(7).findDOMNode,
    isEmpty = __webpack_require__(5),
    computeColorforCSS = __webpack_require__(94),
    getAttsBasedOnDisplay = __webpack_require__(53),
    parseCustomField = __webpack_require__(38),
    parseValue = __webpack_require__(42);

var Button = React.createClass({
	displayName: 'Button',

triggerDisplayChange: false,

getInitialState: function getInitialState() {
		return {
			hovered: false
		};
	},

getWrapperClass: function getWrapperClass(atts) {

var wrapperClass = 'tatsu-module tatsu-normal-button tatsu-button-wrap ',
		    alignment = atts.get('alignment'),
		    type = atts.get('type');

// if ( this.props.builderMode === 'header_builder' ){
		// 	wrapperClass =  wrapperClass + 'tatsu-header-module' ;	
		// }	
		if (!isEmpty(type) && 'block' === type) {
			alignment = 'center';
		}
		if (!isEmpty(alignment)) {
			alignment = 'align-block block-' + alignment;
		} else {
			alignment = '';
		}
		wrapperClass = wrapperClass + alignment;
		return wrapperClass;
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

var isInline = this.props.moduleOptions.getIn([this.props.module.get('name'), 'inline']);
		if (isInline && (this.props.module.getIn(['atts', 'alignment']) != nextProps.module.getIn(['atts', 'alignment']) || this.props.module.getIn(['atts', 'type']) != nextProps.module.getIn(['atts', 'type']))) {
			this.triggerDisplayChange = true;
		}
	},

getButtonClass: function getButtonClass(atts) {

componentDidMount: function componentDidMount() {

var isInline = this.props.moduleOptions.getIn([this.props.module.get('name'), 'inline']);
		if (isInline && (!isEmpty(this.props.module.getIn(['atts', 'alignment'])) || 'block' === this.props.module.getIn(['atts', 'type']))) {
			findDOMNode(this).parentElement.style.display = 'block';
			findDOMNode(this).parentElement.style.width = '100%';
		}
	},

componentDidUpdate: function componentDidUpdate() {

hoverHandler: function hoverHandler() {
		this.setState({
			hovered: !this.state.hovered
		});
	},

render: function render(atts) {

var button = this.props.module,
		    moduleName = button.get('name'),
		    moduleOptions = this.props.moduleOptions,
		    attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']),
		    atts = getAttsBasedOnDisplay(button.get('atts'), this.props.targetDisplay, attsFromModuleOptions),
		    deviceVisibility = atts.get('hide_in'),
		    cssObject = this.props.cssObject.style,
		    url = '',
		    newTab = '',
		    wrapperClass = '',
		    buttonClass = '',
		    buttonStyle = {},
		    buttonHoverStyle = {},
		    hoverEffect = atts.get('hover_effect'),
		    backgroundAnimation = '',
		    lightbox = '',
		    image = '',
		    buttonText = '',
		    bgColor = '',
		    hoverBgColor = '',
		    icon = '',
		    iconAlignment = '',
		    alignmentButton = '',
		    wrapperStyle,

//Append Key to Button Wrapper Class only when button is called as a Child Module within Button Group
		key = this.props.buttonGroup === true ? button.get('id') : '',
		    keyClass = key != '' ? '.' + key + ' ' : '',
		    keyClassNoSpace = key != '' ? '.' + key : '',
		    visibilityClass = ' ',
		    rootStyle = '',
		    visibilityArray;

if (!isEmpty(atts)) {
			backgroundAnimation = atts.get('background_animation'), icon = atts.get('icon');
			iconAlignment = atts.get('icon_alignment');
			alignmentButton = atts.get('alignment');
			if (isEmpty(iconAlignment)) {
				iconAlignment = 'left';
			}
			url = atts.get('url');
			image = atts.get('image');
			lightbox = atts.get('lightbox');
			if (!isEmpty(lightbox) && ('undefined' === typeof url || '' === url) && !isEmpty(image)) {
				url = image;
			}
			newTab = atts.get('new_tab');
			if (isEmpty(atts.get('bg_color'))) {
				bgColor = 'transparent';
			} else {
				bgColor = computeColorforCSS(atts.get('bg_color')).color;
			}
			if (isEmpty(atts.get('hover_bg_color'))) {
				hoverBgColor = bgColor;
			} else {
				hoverBgColor = computeColorforCSS(atts.get('hover_bg_color')).color;
			}
			wrapperClass = this.getWrapperClass(atts);
			buttonClass = this.getButtonClass(atts);
			buttonText = parseCustomField(atts.get('button_text'));
			if ('undefined' === typeof buttonText) {
				buttonText = '';
			}
		}
		// Create Styling Objects from Module Options Array and Atts
		buttonStyle = jQuery.extend({}, cssObject[keyClass + '.tatsu-button'], cssObject[keyClass + '.tatsu-shortcode']);

if (!isEmpty(backgroundAnimation)) {
			if (backgroundAnimation == 'bg-animation-slide-top' || backgroundAnimation == 'bg-animation-slide-bottom') {
				buttonStyle.backgroundImage = 'linear-gradient(to bottom, ' + bgColor + ' 50%, ' + hoverBgColor + ' 50%)';
			}
			if (backgroundAnimation == 'bg-animation-slide-left' || backgroundAnimation == 'bg-animation-slide-right') {
				buttonStyle.backgroundImage = 'linear-gradient(to right, ' + bgColor + ' 50%, ' + hoverBgColor + ' 50%)';
			}
		}

// if( !isEmpty( deviceVisibility ) ) {

// 	visibilityArray = deviceVisibility.split( ',' );
		// 	visibilityArray.forEach( function( device, index ) {
		// 		visibilityClass = visibilityClass + 'tatsu-hide-' + device + ' ';
		// 	} ) 
		// }

// buttonHoverStyle = jQuery.extend( {} , buttonStyle, cssObject[keyClass + '.tatsu-button:hover'] );
		buttonHoverStyle = jQuery.extend({}, buttonStyle, cssObject[keyClass + '.tatsu-button:hover'], cssObject[keyClass + '.tatsu-button-wrap .tatsu-button:hover']);
		wrapperStyle = alignmentButton == 'none' ? cssObject[keyClassNoSpace + '.tatsu-button-wrap'] : cssObject[keyClassNoSpace + '.tatsu-normal-button'];
		rootStyle = this.props.buttonGroup ? cssObject[keyClassNoSpace] : cssObject['root'];
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: wrapperClass + ' ' + key + ' ' + hoverEffect + ' ' + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, wrapperStyle, rootStyle) }),
			React.createElement(
				'a',
				{ className: buttonClass, onMouseEnter: this.hoverHandler, onMouseLeave: this.hoverHandler, style: this.state.hovered ? buttonHoverStyle : buttonStyle, target: newTab ? '_blank' : null, href: url },
				!isEmpty(icon) ? 'left' === iconAlignment ? [React.createElement('i', { className: "tatsu-icon " + icon }), buttonText] : [buttonText, React.createElement('i', { className: "tatsu-icon " + icon })] : buttonText
			)
		);
	}
});
module.exports = Button;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(15), __webpack_require__(12)))

/***/ }),
/* 381 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateIdentifierId, generateVisibilityClasses) {

var parseValue = __webpack_require__(42),
    findDOMNode = __webpack_require__(7).findDOMNode,
    isEmpty = __webpack_require__(5);
var Icon = React.createClass({
	displayName: 'Icon',

getInitialState: function getInitialState() {
		return {
			hovered: false
		};
	},

onHover: function onHover() {
		this.setState({
			hovered: !this.state.hovered
		});
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

var isInline = this.props.moduleOptions.getIn([this.props.module.get('name'), 'inline']);
		if (isInline && this.props.module.getIn(['atts', 'alignment']) != nextProps.module.getIn(['atts', 'alignment'])) {
			this.triggerDisplayChange = true;
		}
	},

getAnchorClass: function getAnchorClass(atts, href) {

var anchorClass = '',
		    style = atts.get('style'),
		    lightbox = atts.get('lightbox'),
		    image = atts.get('image');

if (!isEmpty(style)) {
			anchorClass = anchorClass + style + ' ';
		}
		if (!isEmpty(lightbox)) {
			if (!isEmpty(href)) {
				anchorClass = anchorClass + 'mfp-iframe ';
			} else if (!isEmpty(image)) {
				anchorClass = anchorClass + 'mfp-image ';
			}
		}
		return anchorClass;
	},

getIconClass: function getIconClass(atts) {

componentDidMount: function componentDidMount() {

var isInline = this.props.moduleOptions.getIn([this.props.module.get('name'), 'inline']);
		if (isInline && !isEmpty(this.props.module.getIn(['atts', 'alignment']))) {
			findDOMNode(this).parentElement.style.display = 'block';
		}
	},

componentDidUpdate: function componentDidUpdate() {

if ('undefined' == typeof this.props.parentId) {
			if (this.triggerDisplayChange) {
				if (isEmpty(this.props.module.getIn(['atts', 'alignment']))) {
					findDOMNode(this).parentElement.style.display = 'inline-block';
				} else {
					findDOMNode(this).parentElement.style.display = 'block';
				}
			}
		} else {
			if (this.triggerDisplayChange) {
				if (isEmpty(this.props.module.getIn(['atts', 'alignment']))) {
					findDOMNode(this).style.display = 'inline-block';
				} else {
					findDOMNode(this).style.display = 'block';
				}
			}
		}
	},

render: function render() {

var icon = this.props.module,
		    hasParent = this.props.hasParent || false,
		    id = hasParent ? "." + icon.get('id') + " " : "",
		    idNoSpace = hasParent ? "." + icon.get('id') : "",
		    moduleOptions = this.props.moduleOptions,
		    atts = icon.get('atts'),
		    deviceVisibility = atts.get('hide_in'),
		    outerDivClass = '',
		    hrefValue = '#',

// color = atts.get( 'color' ),
		// hoverColor = atts.get( 'hover_color' ),
		// style = atts.get( 'style' ),
		// bgColor,
		// hoverBgColor,
		// borderColor,
		alignmentFromAtts = atts.get('alignment'),
		    hover_effect_parent_class = alignmentFromAtts === 'none' && 'none' != atts.get('hover_effect') ? atts.get('hover_effect') : '',
		    hover_effect_child_class = alignmentFromAtts !== 'none' && 'none' != atts.get('hover_effect') ? atts.get('hover_effect') : '',

// hoverBorderColor,
		// anchorAttributes = {},  
		newTab = atts.get('new_tab'),
		    hrefFromAtts = atts.get('href'),
		    imageFromAtts = atts.get('image'),
		    iconStyleAtts = atts.get('style'),
		    anchorClass = this.getAnchorClass(atts, hrefFromAtts),
		    iconClass = this.getIconClass(atts),
		    cssObject = this.props.cssObject.style,
		    iconStyle = jQuery.extend({}, cssObject[id + '.tatsu-icon'], cssObject[id + '.tatsu-custom-icon'], cssObject[id + '.tatsu-custom-icon-class']),

// key = ( this.props.iconGroup === true ) ? icon.get('id') : '',
		// keyClass = key != '' ? '.' + key + ' ' : '',
		//	iconShadowStyle = alignmentFromAtts === 'none' ? cssObject[id+'.tatsu-icon-shortcode:hover .tatsu-icon-wrap .tatsu-icon'] : cssObject[id+'.tatsu-icon-shortcode .tatsu-icon-wrap:hover .tatsu-icon'],
		iconHoverStyle = jQuery.extend({}, iconStyle, cssObject[id + '.tatsu-icon:hover']),
		    hasRipple = 'circle' === iconStyleAtts && !isEmpty(atts.get('ripple_effect')) ? true : false,
		    rippleClass = '',
		    visibilityClass = ' ',
		    rootStyle = this.props.iconGroup ? cssObject[idNoSpace] : cssObject['root'],
		    visibilityArray;

if (!isEmpty(imageFromAtts)) {
			hrefValue = imageFromAtts;
		} else if (!isEmpty(hrefFromAtts)) {
			hrefValue = hrefFromAtts;
		}
		if (null != alignmentFromAtts) {
			outerDivClass = alignmentFromAtts;
		}
		// if( !isEmpty( newTab ) ) {
		// 		anchorAttributes.target = '_blank';
		// }
		// if( !isEmpty( style ) && 'plain' != style ) {
		// 	bgColor = atts.get( 'bg_color' );
		// 	hoverBgColor = atts.get( 'hover_bg_color' );
		// 	borderColor = atts.get( 'border_color' );
		// 	hoverBorderColor = atts.get( 'hover_border_color' );
		// }

// if( !isEmpty( deviceVisibility ) ) {

if (hasRipple) {
			rippleClass = ' tatsu-icon-ripple';
		}

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-normal-icon tatsu-icon-shortcode align-" + outerDivClass + ' ' + hover_effect_parent_class + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject[idNoSpace + '.tatsu-normal-icon'], rootStyle) }),
			React.createElement(
				'a',
				{ href: hrefValue, className: "tatsu-icon-wrap " + anchorClass + ' ' + iconStyleAtts + ' ' + hover_effect_child_class, target: !isEmpty(atts.get('new_tab')) ? '_blank' : null },
				React.createElement('i', { className: "tatsu-icon " + iconClass, style: this.state.hovered ? iconHoverStyle : iconStyle, onMouseEnter: this.onHover, onMouseLeave: this.onHover })
			)
		);
	}

});
module.exports = Icon;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(15), __webpack_require__(12)))

/***/ }),
/* 382 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var Tinymce = __webpack_require__(1284),
    shortId = __webpack_require__(116);
var InlineInner = React.createClass({
    displayName: 'InlineInner',

inlineId: null,
    shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
        return false;
    },

componentWillMount: function componentWillMount() {
        this.inlineId = shortId.generate(); //this cannot be id of the model as tinymce will not reinitialize scripts.
    },

componentDidMount: function componentDidMount() {

var tatsuPreview = document.getElementById('tatsu-preview');
        if (tatsuPreview && this.inlineId) {
            tatsuPreview.contentWindow.postMessage('trigger_inline_editor,#' + this.inlineId, '*');
        }
    },

render: function render() {

return React.createElement(Tinymce, {
            id: this.inlineId,
            className: 'tatsu-inline-editor',
            content: this.props.content,
            config: {
                inline: true,
                plugins: 'textcolor colorpicker lists advlist',
                toolbar: false,
                statusbar: false,
                menubar: false,
                content_editable: true
            }
        });
    }

});
module.exports = InlineInner;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 383 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(795), __esModule: true };

/***/ }),
/* 384 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(797), __esModule: true };

/***/ }),
/* 385 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var GetIntrinsic = __webpack_require__(413);

var callBind = __webpack_require__(243);

var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));

module.exports = function callBoundIntrinsic(name, allowMissing) {
	var intrinsic = GetIntrinsic(name, !!allowMissing);
	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
		return callBind(intrinsic);
	}
	return intrinsic;
};

/***/ }),
/* 386 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * Module dependencies.
 */

try {
  var index = __webpack_require__(387);
} catch (err) {
  var index = __webpack_require__(387);
}

/**
 * Whitespace regexp.
 */

var re = /\s+/;

/**
 * toString reference.
 */

var toString = Object.prototype.toString;

/**
 * Wrap `el` in a `ClassList`.
 *
 * @param {Element} el
 * @return {ClassList}
 * @api public
 */

module.exports = function(el){
  return new ClassList(el);
};

/**
 * Initialize a new ClassList for `el`.
 *
 * @param {Element} el
 * @api private
 */

function ClassList(el) {
  if (!el || !el.nodeType) {
    throw new Error('A DOM element reference is required');
  }
  this.el = el;
  this.list = el.classList;
}

/**
 * Add class `name` if not already present.
 *
 * @param {String} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.add = function(name){
  // classList
  if (this.list) {
    this.list.add(name);
    return this;
  }

// fallback
  var arr = this.array();
  var i = index(arr, name);
  if (!~i) arr.push(name);
  this.el.className = arr.join(' ');
  return this;
};

/**
 * Remove class `name` when present, or
 * pass a regular expression to remove
 * any which match.
 *
 * @param {String|RegExp} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.remove = function(name){
  if ('[object RegExp]' == toString.call(name)) {
    return this.removeMatching(name);
  }

// classList
  if (this.list) {
    this.list.remove(name);
    return this;
  }

// fallback
  var arr = this.array();
  var i = index(arr, name);
  if (~i) arr.splice(i, 1);
  this.el.className = arr.join(' ');
  return this;
};

/**
 * Remove all classes matching `re`.
 *
 * @param {RegExp} re
 * @return {ClassList}
 * @api private
 */

ClassList.prototype.removeMatching = function(re){
  var arr = this.array();
  for (var i = 0; i < arr.length; i++) {
    if (re.test(arr[i])) {
      this.remove(arr[i]);
    }
  }
  return this;
};

/**
 * Toggle class `name`, can force state via `force`.
 *
 * For browsers that support classList, but do not support `force` yet,
 * the mistake will be detected and corrected.
 *
 * @param {String} name
 * @param {Boolean} force
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.toggle = function(name, force){
  // classList
  if (this.list) {
    if ("undefined" !== typeof force) {
      if (force !== this.list.toggle(name, force)) {
        this.list.toggle(name); // toggle again to correct
      }
    } else {
      this.list.toggle(name);
    }
    return this;
  }

// fallback
  if ("undefined" !== typeof force) {
    if (!force) {
      this.remove(name);
    } else {
      this.add(name);
    }
  } else {
    if (this.has(name)) {
      this.remove(name);
    } else {
      this.add(name);
    }
  }

return this;
};

/**
 * Return an array of classes.
 *
 * @return {Array}
 * @api public
 */

ClassList.prototype.array = function(){
  var className = this.el.getAttribute('class') || '';
  var str = className.replace(/^\s+|\s+$/g, '');
  var arr = str.split(re);
  if ('' === arr[0]) arr.shift();
  return arr;
};

/**
 * Check if class `name` is present.
 *
 * @param {String} name
 * @return {ClassList}
 * @api public
 */

ClassList.prototype.has =
ClassList.prototype.contains = function(name){
  return this.list
    ? this.list.contains(name)
    : !! ~index(this.array(), name);
};

/***/ }),
/* 387 */
/***/ (function(module, exports) {

module.exports = function(arr, obj){
  if (arr.indexOf) return arr.indexOf(obj);
  for (var i = 0; i < arr.length; ++i) {
    if (arr[i] === obj) return i;
  }
  return -1;
};

/***/ }),
/* 388 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(103);
var document = __webpack_require__(70).document;
// typeof document.createElement is 'object' in old IE
var is = isObject(document) && isObject(document.createElement);
module.exports = function (it) {
  return is ? document.createElement(it) : {};
};

/***/ }),
/* 389 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = !__webpack_require__(68) && !__webpack_require__(101)(function () {
  return Object.defineProperty(__webpack_require__(388)('div'), 'a', { get: function () { return 7; } }).a != 7;
});

/***/ }),
/* 390 */
/***/ (function(module, exports, __webpack_require__) {

// fallback for non-array-like ES3 and non-enumerable old V8 strings
var cof = __webpack_require__(245);
// eslint-disable-next-line no-prototype-builtins
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
  return cof(it) == 'String' ? it.split('') : Object(it);
};

/***/ }),
/* 391 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var LIBRARY = __webpack_require__(162);
var $export = __webpack_require__(69);
var redefine = __webpack_require__(395);
var hide = __webpack_require__(102);
var Iterators = __webpack_require__(127);
var $iterCreate = __webpack_require__(812);
var setToStringTag = __webpack_require__(253);
var getPrototypeOf = __webpack_require__(393);
var ITERATOR = __webpack_require__(55)('iterator');
var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
var FF_ITERATOR = '@@iterator';
var KEYS = 'keys';
var VALUES = 'values';

var returnThis = function () { return this; };

module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
  $iterCreate(Constructor, NAME, next);
  var getMethod = function (kind) {
    if (!BUGGY && kind in proto) return proto[kind];
    switch (kind) {
      case KEYS: return function keys() { return new Constructor(this, kind); };
      case VALUES: return function values() { return new Constructor(this, kind); };
    } return function entries() { return new Constructor(this, kind); };
  };
  var TAG = NAME + ' Iterator';
  var DEF_VALUES = DEFAULT == VALUES;
  var VALUES_BUG = false;
  var proto = Base.prototype;
  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
  var $default = $native || getMethod(DEFAULT);
  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
  var methods, key, IteratorPrototype;
  // Fix native
  if ($anyNative) {
    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
      // Set @@toStringTag to native iterators
      setToStringTag(IteratorPrototype, TAG, true);
      // fix for some old engines
      if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);
    }
  }
  // fix Array#{values, @@iterator}.name in V8 / FF
  if (DEF_VALUES && $native && $native.name !== VALUES) {
    VALUES_BUG = true;
    $default = function values() { return $native.call(this); };
  }
  // Define iterator
  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
    hide(proto, ITERATOR, $default);
  }
  // Plug for library
  Iterators[NAME] = $default;
  Iterators[TAG] = returnThis;
  if (DEFAULT) {
    methods = {
      values: DEF_VALUES ? $default : getMethod(VALUES),
      keys: IS_SET ? $default : getMethod(KEYS),
      entries: $entries
    };
    if (FORCED) for (key in methods) {
      if (!(key in proto)) redefine(proto, key, methods[key]);
    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
  }
  return methods;
};

/***/ }),
/* 392 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
var $keys = __webpack_require__(394);
var hiddenKeys = __webpack_require__(248).concat('length', 'prototype');

exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
  return $keys(O, hiddenKeys);
};

/***/ }),
/* 393 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
var has = __webpack_require__(81);
var toObject = __webpack_require__(104);
var IE_PROTO = __webpack_require__(254)('IE_PROTO');
var ObjectProto = Object.prototype;

module.exports = Object.getPrototypeOf || function (O) {
  O = toObject(O);
  if (has(O, IE_PROTO)) return O[IE_PROTO];
  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
    return O.constructor.prototype;
  } return O instanceof Object ? ObjectProto : null;
};

/***/ }),
/* 394 */
/***/ (function(module, exports, __webpack_require__) {

var has = __webpack_require__(81);
var toIObject = __webpack_require__(82);
var arrayIndexOf = __webpack_require__(804)(false);
var IE_PROTO = __webpack_require__(254)('IE_PROTO');

module.exports = function (object, names) {
  var O = toIObject(object);
  var i = 0;
  var result = [];
  var key;
  for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
  // Don't enum bug & hidden keys
  while (names.length > i) if (has(O, key = names[i++])) {
    ~arrayIndexOf(result, key) || result.push(key);
  }
  return result;
};

/***/ }),
/* 395 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(102);

/***/ }),
/* 396 */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.15 ToLength
var toInteger = __webpack_require__(256);
var min = Math.min;
module.exports = function (it) {
  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
};

/***/ }),
/* 397 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $at = __webpack_require__(820)(true);

// 21.1.3.27 String.prototype[@@iterator]()
__webpack_require__(391)(String, 'String', function (iterated) {
  this._t = String(iterated); // target
  this._i = 0;                // next index
// 21.1.5.2.1 %StringIteratorPrototype%.next()
}, function () {
  var O = this._t;
  var index = this._i;
  var point;
  if (index >= O.length) return { value: undefined, done: true };
  point = $at(O, index);
  this._i += point.length;
  return { value: point, done: false };
});

/***/ }),
/* 398 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
var START_EVENT_NAME_MAP = {
  transitionstart: {
    transition: 'transitionstart',
    WebkitTransition: 'webkitTransitionStart',
    MozTransition: 'mozTransitionStart',
    OTransition: 'oTransitionStart',
    msTransition: 'MSTransitionStart'
  },

animationstart: {
    animation: 'animationstart',
    WebkitAnimation: 'webkitAnimationStart',
    MozAnimation: 'mozAnimationStart',
    OAnimation: 'oAnimationStart',
    msAnimation: 'MSAnimationStart'
  }
};

var END_EVENT_NAME_MAP = {
  transitionend: {
    transition: 'transitionend',
    WebkitTransition: 'webkitTransitionEnd',
    MozTransition: 'mozTransitionEnd',
    OTransition: 'oTransitionEnd',
    msTransition: 'MSTransitionEnd'
  },

animationend: {
    animation: 'animationend',
    WebkitAnimation: 'webkitAnimationEnd',
    MozAnimation: 'mozAnimationEnd',
    OAnimation: 'oAnimationEnd',
    msAnimation: 'MSAnimationEnd'
  }
};

var startEvents = [];
var endEvents = [];

function detectEvents() {
  var testEl = document.createElement('div');
  var style = testEl.style;

if (!('AnimationEvent' in window)) {
    delete START_EVENT_NAME_MAP.animationstart.animation;
    delete END_EVENT_NAME_MAP.animationend.animation;
  }

if (!('TransitionEvent' in window)) {
    delete START_EVENT_NAME_MAP.transitionstart.transition;
    delete END_EVENT_NAME_MAP.transitionend.transition;
  }

process(START_EVENT_NAME_MAP, startEvents);
  process(END_EVENT_NAME_MAP, endEvents);
}

if (typeof window !== 'undefined' && typeof document !== 'undefined') {
  detectEvents();
}

function addEventListener(node, eventName, eventListener) {
  node.addEventListener(eventName, eventListener, false);
}

function removeEventListener(node, eventName, eventListener) {
  node.removeEventListener(eventName, eventListener, false);
}

var TransitionEvents = {
  // Start events
  startEvents: startEvents,

addStartEventListener: function addStartEventListener(node, eventListener) {
    if (startEvents.length === 0) {
      window.setTimeout(eventListener, 0);
      return;
    }
    startEvents.forEach(function (startEvent) {
      addEventListener(node, startEvent, eventListener);
    });
  },
  removeStartEventListener: function removeStartEventListener(node, eventListener) {
    if (startEvents.length === 0) {
      return;
    }
    startEvents.forEach(function (startEvent) {
      removeEventListener(node, startEvent, eventListener);
    });
  },

// End events
  endEvents: endEvents,

addEndEventListener: function addEndEventListener(node, eventListener) {
    if (endEvents.length === 0) {
      window.setTimeout(eventListener, 0);
      return;
    }
    endEvents.forEach(function (endEvent) {
      addEventListener(node, endEvent, eventListener);
    });
  },
  removeEndEventListener: function removeEndEventListener(node, eventListener) {
    if (endEvents.length === 0) {
      return;
    }
    endEvents.forEach(function (endEvent) {
      removeEventListener(node, endEvent, eventListener);
    });
  }
};

/* harmony default export */ __webpack_exports__["a"] = (TransitionEvents);

/***/ }),
/* 399 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.default = dirtyHandlerIds;
exports.areDirty = areDirty;

var _xor = __webpack_require__(1099);

var _xor2 = _interopRequireDefault(_xor);

var _intersection = __webpack_require__(1085);

var _intersection2 = _interopRequireDefault(_intersection);

var _dragDrop = __webpack_require__(165);

var _registry = __webpack_require__(166);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var NONE = [];
var ALL = [];

function dirtyHandlerIds() {
	var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : NONE;
	var action = arguments[1];
	var dragOperation = arguments[2];

switch (action.type) {
		case _dragDrop.HOVER:
			break;
		case _registry.ADD_SOURCE:
		case _registry.ADD_TARGET:
		case _registry.REMOVE_TARGET:
		case _registry.REMOVE_SOURCE:
			return NONE;
		case _dragDrop.BEGIN_DRAG:
		case _dragDrop.PUBLISH_DRAG_SOURCE:
		case _dragDrop.END_DRAG:
		case _dragDrop.DROP:
		default:
			return ALL;
	}

var targetIds = action.targetIds;
	var prevTargetIds = dragOperation.targetIds;

var result = (0, _xor2.default)(targetIds, prevTargetIds);

if (!didChange) {
		return NONE;
	}

var prevInnermostTargetId = prevTargetIds[prevTargetIds.length - 1];
	var innermostTargetId = targetIds[targetIds.length - 1];

if (prevInnermostTargetId !== innermostTargetId) {
		if (prevInnermostTargetId) {
			result.push(prevInnermostTargetId);
		}
		if (innermostTargetId) {
			result.push(innermostTargetId);
		}
	}

return result;
}

function areDirty(state, handlerIds) {
	if (state === NONE) {
		return false;
	}

if (state === ALL || typeof handlerIds === 'undefined') {
		return true;
	}

return (0, _intersection2.default)(handlerIds, state).length > 0;
}

/***/ }),
/* 400 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

exports.default = dragOffset;
exports.getSourceClientOffset = getSourceClientOffset;
exports.getDifferenceFromInitialOffset = getDifferenceFromInitialOffset;

var _dragDrop = __webpack_require__(165);

var initialState = {
	initialSourceClientOffset: null,
	initialClientOffset: null,
	clientOffset: null
};

function areOffsetsEqual(offsetA, offsetB) {
	if (offsetA === offsetB) {
		return true;
	}
	return offsetA && offsetB && offsetA.x === offsetB.x && offsetA.y === offsetB.y;
}

function dragOffset() {
	var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
	var action = arguments[1];

switch (action.type) {
		case _dragDrop.BEGIN_DRAG:
			return {
				initialSourceClientOffset: action.sourceClientOffset,
				initialClientOffset: action.clientOffset,
				clientOffset: action.clientOffset
			};
		case _dragDrop.HOVER:
			if (areOffsetsEqual(state.clientOffset, action.clientOffset)) {
				return state;
			}
			return _extends({}, state, {
				clientOffset: action.clientOffset
			});
		case _dragDrop.END_DRAG:
		case _dragDrop.DROP:
			return initialState;
		default:
			return state;
	}
}

function getSourceClientOffset(state) {
	var clientOffset = state.clientOffset,
	    initialClientOffset = state.initialClientOffset,
	    initialSourceClientOffset = state.initialSourceClientOffset;

if (!clientOffset || !initialClientOffset || !initialSourceClientOffset) {
		return null;
	}
	return {
		x: clientOffset.x + initialSourceClientOffset.x - initialClientOffset.x,
		y: clientOffset.y + initialSourceClientOffset.y - initialClientOffset.y
	};
}

function getDifferenceFromInitialOffset(state) {
	var clientOffset = state.clientOffset,
	    initialClientOffset = state.initialClientOffset;

if (!clientOffset || !initialClientOffset) {
		return null;
	}
	return {
		x: clientOffset.x - initialClientOffset.x,
		y: clientOffset.y - initialClientOffset.y
	};
}

/***/ }),
/* 401 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.default = matchesType;

var _isArray = __webpack_require__(27);

var _isArray2 = _interopRequireDefault(_isArray);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ }),
/* 402 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = __webpack_require__(867);

/***/ }),
/* 403 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var detector = module.exports = {};

detector.isIE = function(version) {
    function isAnyIeVersion() {
        var agent = navigator.userAgent.toLowerCase();
        return agent.indexOf("msie") !== -1 || agent.indexOf("trident") !== -1 || agent.indexOf(" edge/") !== -1;
    }

if(!isAnyIeVersion()) {
        return false;
    }

if(!version) {
        return true;
    }

//Shamelessly stolen from https://gist.github.com/padolsey/527683
    var ieVersion = (function(){
        var undef,
            v = 3,
            div = document.createElement("div"),
            all = div.getElementsByTagName("i");

do {
            div.innerHTML = "";
        }
        while (all[0]);

return v > 4 ? v : undef;
    }());

return version === ieVersion;
};

detector.isLegacyOpera = function() {
    return !!window.opera;
};

/***/ }),
/* 404 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = module.exports = {};

/**
 * Loops through the collection and calls the callback for each element. if the callback returns truthy, the loop is broken and returns the same value.
 * @public
 * @param {*} collection The collection to loop through. Needs to have a length property set and have indices set from 0 to length - 1.
 * @param {function} callback The callback to be called for each element. The element will be given as a parameter to the callback. If this callback returns truthy, the loop is broken and the same value is returned.
 * @returns {*} The value that a callback has returned (if truthy). Otherwise nothing.
 */
utils.forEach = function(collection, callback) {
    for(var i = 0; i < collection.length; i++) {
        var result = callback(collection[i]);
        if(result) {
            return result;
        }
    }
};

/***/ }),
/* 405 */
/***/ (function(module, exports) {

/**
 * Helper function for iterating over a collection
 *
 * @param collection
 * @param fn
 */
function each(collection, fn) {
    var i      = 0,
        length = collection.length,
        cont;

for(i; i < length; i++) {
        cont = fn(collection[i], i);
        if(cont === false) {
            break; //allow early exit
        }
    }
}

/**
 * Helper function for determining whether target object is an array
 *
 * @param target the object under test
 * @return {Boolean} true if array, false otherwise
 */
function isArray(target) {
    return Object.prototype.toString.apply(target) === '[object Array]';
}

/**
 * Helper function for determining whether target object is a function
 *
 * @param target the object under test
 * @return {Boolean} true if function, false otherwise
 */
function isFunction(target) {
    return typeof target === 'function';
}

module.exports = {
    isFunction : isFunction,
    isArray : isArray,
    each : each
};

/***/ }),
/* 406 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 407 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 408 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 409 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 410 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @typechecks
 */

var emptyFunction = __webpack_require__(44);

/**
 * Upstream version of event listener. Does not take into account specific
 * nature of platform.
 */
var EventListener = {
  /**
   * Listen to DOM events during the bubble phase.
   *
   * @param {DOMEventTarget} target DOM element to register listener on.
   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
   * @param {function} callback Callback function.
   * @return {object} Object with a `remove` method.
   */
  listen: function listen(target, eventType, callback) {
    if (target.addEventListener) {
      target.addEventListener(eventType, callback, false);
      return {
        remove: function remove() {
          target.removeEventListener(eventType, callback, false);
        }
      };
    } else if (target.attachEvent) {
      target.attachEvent('on' + eventType, callback);
      return {
        remove: function remove() {
          target.detachEvent('on' + eventType, callback);
        }
      };
    }
  },

/**
   * Listen to DOM events during the capture phase.
   *
   * @param {DOMEventTarget} target DOM element to register listener on.
   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
   * @param {function} callback Callback function.
   * @return {object} Object with a `remove` method.
   */
  capture: function capture(target, eventType, callback) {
    if (target.addEventListener) {
      target.addEventListener(eventType, callback, true);
      return {
        remove: function remove() {
          target.removeEventListener(eventType, callback, true);
        }
      };
    } else {
      if (process.env.NODE_ENV !== 'production') {
        console.error('Attempted to listen to events during the capture phase on a ' + 'browser that does not support the capture phase. Your application ' + 'will not receive some events.');
      }
      return {
        remove: emptyFunction
      };
    }
  },

registerDefault: function registerDefault() {}
};

module.exports = EventListener;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 411 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

/**
 * @param {DOMElement} node input/textarea to focus
 */

function focusNode(node) {
  // IE8 can throw "Can't move focus to the control because it is invisible,
  // not enabled, or of a type that does not accept the focus." for all kinds of
  // reasons that are too expensive and fragile to test.
  try {
    node.focus();
  } catch (e) {}
}

module.exports = focusNode;

/***/ }),
/* 412 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/* eslint-disable fb-www/typeof-undefined */

/**
 * Same as document.activeElement but wraps in a try-catch block. In IE it is
 * not safe to call document.activeElement if there is nothing focused.
 *
 * The activeElement will be null only if the document or document body is not
 * yet defined.
 *
 * @param {?DOMDocument} doc Defaults to current document.
 * @return {?DOMElement}
 */
function getActiveElement(doc) /*?DOMElement*/{
  doc = doc || (typeof document !== 'undefined' ? document : undefined);
  if (typeof doc === 'undefined') {
    return null;
  }
  try {
    return doc.activeElement || doc.body;
  } catch (e) {
    return doc.body;
  }
}

module.exports = getActiveElement;

/***/ }),
/* 413 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var undefined;

var $SyntaxError = SyntaxError;
var $Function = Function;
var $TypeError = TypeError;

// eslint-disable-next-line consistent-return
var getEvalledConstructor = function (expressionSyntax) {
	try {
		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
	} catch (e) {}
};

var $gOPD = Object.getOwnPropertyDescriptor;
if ($gOPD) {
	try {
		$gOPD({}, '');
	} catch (e) {
		$gOPD = null; // this is IE 8, which has a broken gOPD
	}
}

var hasSymbols = __webpack_require__(946)();

var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto

var needsEval = {};

var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);

var INTRINSICS = {
	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
	'%Array%': Array,
	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
	'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
	'%AsyncFromSyncIteratorPrototype%': undefined,
	'%AsyncFunction%': needsEval,
	'%AsyncGenerator%': needsEval,
	'%AsyncGeneratorFunction%': needsEval,
	'%AsyncIteratorPrototype%': needsEval,
	'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
	'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
	'%Boolean%': Boolean,
	'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
	'%Date%': Date,
	'%decodeURI%': decodeURI,
	'%decodeURIComponent%': decodeURIComponent,
	'%encodeURI%': encodeURI,
	'%encodeURIComponent%': encodeURIComponent,
	'%Error%': Error,
	'%eval%': eval, // eslint-disable-line no-eval
	'%EvalError%': EvalError,
	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
	'%Function%': $Function,
	'%GeneratorFunction%': needsEval,
	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
	'%isFinite%': isFinite,
	'%isNaN%': isNaN,
	'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
	'%JSON%': typeof JSON === 'object' ? JSON : undefined,
	'%Map%': typeof Map === 'undefined' ? undefined : Map,
	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
	'%Math%': Math,
	'%Number%': Number,
	'%Object%': Object,
	'%parseFloat%': parseFloat,
	'%parseInt%': parseInt,
	'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
	'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
	'%RangeError%': RangeError,
	'%ReferenceError%': ReferenceError,
	'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
	'%RegExp%': RegExp,
	'%Set%': typeof Set === 'undefined' ? undefined : Set,
	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
	'%String%': String,
	'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
	'%Symbol%': hasSymbols ? Symbol : undefined,
	'%SyntaxError%': $SyntaxError,
	'%ThrowTypeError%': ThrowTypeError,
	'%TypedArray%': TypedArray,
	'%TypeError%': $TypeError,
	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
	'%URIError%': URIError,
	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
};

INTRINSICS[name] = value;

return value;
};

var LEGACY_ALIASES = {
	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
	'%ArrayPrototype%': ['Array', 'prototype'],
	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
	'%BooleanPrototype%': ['Boolean', 'prototype'],
	'%DataViewPrototype%': ['DataView', 'prototype'],
	'%DatePrototype%': ['Date', 'prototype'],
	'%ErrorPrototype%': ['Error', 'prototype'],
	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
	'%FunctionPrototype%': ['Function', 'prototype'],
	'%Generator%': ['GeneratorFunction', 'prototype'],
	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
	'%JSONParse%': ['JSON', 'parse'],
	'%JSONStringify%': ['JSON', 'stringify'],
	'%MapPrototype%': ['Map', 'prototype'],
	'%NumberPrototype%': ['Number', 'prototype'],
	'%ObjectPrototype%': ['Object', 'prototype'],
	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
	'%PromisePrototype%': ['Promise', 'prototype'],
	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
	'%Promise_all%': ['Promise', 'all'],
	'%Promise_reject%': ['Promise', 'reject'],
	'%Promise_resolve%': ['Promise', 'resolve'],
	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
	'%RegExpPrototype%': ['RegExp', 'prototype'],
	'%SetPrototype%': ['Set', 'prototype'],
	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
	'%StringPrototype%': ['String', 'prototype'],
	'%SymbolPrototype%': ['Symbol', 'prototype'],
	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
	'%URIErrorPrototype%': ['URIError', 'prototype'],
	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
	'%WeakSetPrototype%': ['WeakSet', 'prototype']
};

var bind = __webpack_require__(264);
var hasOwn = __webpack_require__(947);
var $concat = bind.call(Function.call, Array.prototype.concat);
var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
var $replace = bind.call(Function.call, String.prototype.replace);
var $strSlice = bind.call(Function.call, String.prototype.slice);

/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
var reEscapeChar = /\$\$?/g; /** Used to match backslashes in property paths. */
var stringToPath = function stringToPath(string) {
	var first = $strSlice(string, 0, 1);
	var last = $strSlice(string, -1);
	if (first === '%' && last !== '%') {
		throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
	} else if (last === '%' && first !== '%') {
		throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
	}
	var result = [];
	$replace(string, rePropName, function (match, number, quote, subString) {
		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
	});
	return result;
};
/* end adaptation */

var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
	var intrinsicName = name;
	var alias;
	if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
		alias = LEGACY_ALIASES[intrinsicName];
		intrinsicName = '%' + alias[0] + '%';
	}

if (hasOwn(INTRINSICS, intrinsicName)) {
		var value = INTRINSICS[intrinsicName];
		if (value === needsEval) {
			value = doEval(intrinsicName);
		}
		if (typeof value === 'undefined' && !allowMissing) {
			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
		}

return {
			alias: alias,
			name: intrinsicName,
			value: value
		};
	}

throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
};

module.exports = function GetIntrinsic(name, allowMissing) {
	if (typeof name !== 'string' || name.length === 0) {
		throw new $TypeError('intrinsic name must be a non-empty string');
	}
	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
		throw new $TypeError('"allowMissing" argument must be a boolean');
	}

var parts = stringToPath(name);
	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';

var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
	var intrinsicRealName = intrinsic.name;
	var value = intrinsic.value;
	var skipFurtherCaching = false;

var alias = intrinsic.alias;
	if (alias) {
		intrinsicBaseName = alias[0];
		$spliceApply(parts, $concat([0, 1], alias));
	}

for (var i = 1, isOwn = true; i < parts.length; i += 1) {
		var part = parts[i];
		var first = $strSlice(part, 0, 1);
		var last = $strSlice(part, -1);
		if (
			(
				(first === '"' || first === "'" || first === '`')
				|| (last === '"' || last === "'" || last === '`')
			)
			&& first !== last
		) {
			throw new $SyntaxError('property names with quotes must have matching quotes');
		}
		if (part === 'constructor' || !isOwn) {
			skipFurtherCaching = true;
		}

intrinsicBaseName += '.' + part;
		intrinsicRealName = '%' + intrinsicBaseName + '%';

if (hasOwn(INTRINSICS, intrinsicRealName)) {
			value = INTRINSICS[intrinsicRealName];
		} else if (value != null) {
			if (!(part in value)) {
				if (!allowMissing) {
					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
				}
				return void undefined;
			}
			if ($gOPD && (i + 1) >= parts.length) {
				var desc = $gOPD(value, part);
				isOwn = !!desc;

// By convention, when a data property is converted to an accessor
				// property to emulate a data property that does not suffer from
				// the override mistake, that accessor's getter is marked with
				// an `originalValue` property. Here, when we detect this, we
				// uphold the illusion by pretending to see that original data
				// property, i.e., returning the value rather than the getter
				// itself.
				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
					value = desc.get;
				} else {
					value = value[part];
				}
			} else {
				isOwn = hasOwn(value, part);
				value = value[part];
			}

if (isOwn && !skipFurtherCaching) {
				INTRINSICS[intrinsicRealName] = value;
			}
		}
	}
	return value;
};

/***/ }),
/* 414 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/* eslint complexity: [2, 18], max-statements: [2, 33] */
module.exports = function hasSymbols() {
	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
	if (typeof Symbol.iterator === 'symbol') { return true; }

var obj = {};
	var sym = Symbol('test');
	var symObj = Object(sym);
	if (typeof sym === 'string') { return false; }

if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }

// temp disabled per https://github.com/ljharb/object.assign/issues/17
	// if (sym instanceof Symbol) { return false; }
	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
	// if (!(symObj instanceof Symbol)) { return false; }

// if (typeof Symbol.prototype.toString !== 'function') { return false; }
	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }

var symVal = 42;
	obj[sym] = symVal;
	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }

if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }

var syms = Object.getOwnPropertySymbols(obj);
	if (syms.length !== 1 || syms[0] !== sym) { return false; }

if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }

if (typeof Object.getOwnPropertyDescriptor === 'function') {
		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
	}

return true;
};

/***/ }),
/* 415 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/*eslint-disable no-empty */

exports.__esModule = true;
exports.saveState = saveState;
exports.readState = readState;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

var KeyPrefix = '@@History/';
var QuotaExceededErrors = ['QuotaExceededError', 'QUOTA_EXCEEDED_ERR'];

var SecurityError = 'SecurityError';

function createKey(key) {
  return KeyPrefix + key;
}

return;
    }

if (QuotaExceededErrors.indexOf(error.name) >= 0 && window.sessionStorage.length === 0) {
      // Safari "private mode" throws QuotaExceededError.
      process.env.NODE_ENV !== 'production' ? _warning2['default'](false, '[history] Unable to save state; sessionStorage is not available in Safari private mode') : undefined;

return;
    }

throw error;
  }
}

function readState(key) {
  var json = undefined;
  try {
    json = window.sessionStorage.getItem(createKey(key));
  } catch (error) {
    if (error.name === SecurityError) {
      // Blocking cookies in Chrome/Firefox/Safari throws SecurityError on any
      // attempt to access window.sessionStorage.
      process.env.NODE_ENV !== 'production' ? _warning2['default'](false, '[history] Unable to read state; sessionStorage is not available due to security settings') : undefined;

return null;
    }
  }

if (json) {
    try {
      return JSON.parse(json);
    } catch (error) {
      // Ignore invalid JSON.
    }
  }

return null;
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 416 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _ExecutionEnvironment = __webpack_require__(169);

var _DOMUtils = __webpack_require__(267);

var _createHistory = __webpack_require__(418);

var _createHistory2 = _interopRequireDefault(_createHistory);

function createDOMHistory(options) {
  var history = _createHistory2['default'](_extends({
    getUserConfirmation: _DOMUtils.getUserConfirmation
  }, options, {
    go: _DOMUtils.go
  }));

function listen(listener) {
    !_ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? _invariant2['default'](false, 'DOM history needs a DOM') : _invariant2['default'](false) : undefined;

return history.listen(listener);
  }

return _extends({}, history, {
    listen: listen
  });
}

exports['default'] = createDOMHistory;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 417 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _Actions = __webpack_require__(105);

var _PathUtils = __webpack_require__(83);

var _ExecutionEnvironment = __webpack_require__(169);

var _DOMUtils = __webpack_require__(267);

var _DOMStateStorage = __webpack_require__(415);

var _createDOMHistory = __webpack_require__(416);

var _createDOMHistory2 = _interopRequireDefault(_createDOMHistory);

function isAbsolutePath(path) {
  return typeof path === 'string' && path.charAt(0) === '/';
}

function ensureSlash() {
  var path = _DOMUtils.getHashPath();

if (isAbsolutePath(path)) return true;

_DOMUtils.replaceHashPath('/' + path);

return false;
}

function addQueryStringValueToPath(path, key, value) {
  return path + (path.indexOf('?') === -1 ? '?' : '&') + (key + '=' + value);
}

function stripQueryStringValueFromPath(path, key) {
  return path.replace(new RegExp('[?&]?' + key + '=[a-zA-Z0-9]+'), '');
}

function getQueryStringValueFromPath(path, key) {
  var match = path.match(new RegExp('\\?.*?\\b' + key + '=(.+?)\\b'));
  return match && match[1];
}

var DefaultQueryKey = '_k';

function createHashHistory() {
  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

!_ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? _invariant2['default'](false, 'Hash history needs a DOM') : _invariant2['default'](false) : undefined;

var queryKey = options.queryKey;

if (queryKey === undefined || !!queryKey) queryKey = typeof queryKey === 'string' ? queryKey : DefaultQueryKey;

function getCurrentLocation() {
    var path = _DOMUtils.getHashPath();

var key = undefined,
        state = undefined;
    if (queryKey) {
      key = getQueryStringValueFromPath(path, queryKey);
      path = stripQueryStringValueFromPath(path, queryKey);

if (key) {
        state = _DOMStateStorage.readState(key);
      } else {
        state = null;
        key = history.createKey();
        _DOMUtils.replaceHashPath(addQueryStringValueToPath(path, queryKey, key));
      }
    } else {
      key = state = null;
    }

var location = _PathUtils.parsePath(path);

return history.createLocation(_extends({}, location, { state: state }), undefined, key);
  }

function startHashChangeListener(_ref) {
    var transitionTo = _ref.transitionTo;

function hashChangeListener() {
      if (!ensureSlash()) return; // Always make sure hashes are preceeded with a /.

transitionTo(getCurrentLocation());
    }

ensureSlash();
    _DOMUtils.addEventListener(window, 'hashchange', hashChangeListener);

return function () {
      _DOMUtils.removeEventListener(window, 'hashchange', hashChangeListener);
    };
  }

function finishTransition(location) {
    var basename = location.basename;
    var pathname = location.pathname;
    var search = location.search;
    var state = location.state;
    var action = location.action;
    var key = location.key;

if (action === _Actions.POP) return; // Nothing to do.

var path = (basename || '') + pathname + search;

if (queryKey) {
      path = addQueryStringValueToPath(path, queryKey, key);
      _DOMStateStorage.saveState(key, state);
    } else {
      // Drop key and state.
      location.key = location.state = null;
    }

var currentHash = _DOMUtils.getHashPath();

if (action === _Actions.PUSH) {
      if (currentHash !== path) {
        window.location.hash = path;
      } else {
        process.env.NODE_ENV !== 'production' ? _warning2['default'](false, 'You cannot PUSH the same path using hash history') : undefined;
      }
    } else if (currentHash !== path) {
      // REPLACE
      _DOMUtils.replaceHashPath(path);
    }
  }

var history = _createDOMHistory2['default'](_extends({}, options, {
    getCurrentLocation: getCurrentLocation,
    finishTransition: finishTransition,
    saveState: _DOMStateStorage.saveState
  }));

var listenerCount = 0,
      stopHashChangeListener = undefined;

function listenBefore(listener) {
    if (++listenerCount === 1) stopHashChangeListener = startHashChangeListener(history);

var unlisten = history.listenBefore(listener);

return function () {
      unlisten();

if (--listenerCount === 0) stopHashChangeListener();
    };
  }

function listen(listener) {
    if (++listenerCount === 1) stopHashChangeListener = startHashChangeListener(history);

var unlisten = history.listen(listener);

return function () {
      unlisten();

if (--listenerCount === 0) stopHashChangeListener();
    };
  }

function push(location) {
    process.env.NODE_ENV !== 'production' ? _warning2['default'](queryKey || location.state == null, 'You cannot use state without a queryKey it will be dropped') : undefined;

history.push(location);
  }

function replace(location) {
    process.env.NODE_ENV !== 'production' ? _warning2['default'](queryKey || location.state == null, 'You cannot use state without a queryKey it will be dropped') : undefined;

history.replace(location);
  }

var goIsSupportedWithoutReload = _DOMUtils.supportsGoWithoutReloadUsingHash();

function go(n) {
    process.env.NODE_ENV !== 'production' ? _warning2['default'](goIsSupportedWithoutReload, 'Hash history go(n) causes a full page reload in this browser') : undefined;

history.go(n);
  }

function createHref(path) {
    return '#' + history.createHref(path);
  }

// deprecated
  function registerTransitionHook(hook) {
    if (++listenerCount === 1) stopHashChangeListener = startHashChangeListener(history);

history.registerTransitionHook(hook);
  }

// deprecated
  function unregisterTransitionHook(hook) {
    history.unregisterTransitionHook(hook);

if (--listenerCount === 0) stopHashChangeListener();
  }

// deprecated
  function pushState(state, path) {
    process.env.NODE_ENV !== 'production' ? _warning2['default'](queryKey || state == null, 'You cannot use state without a queryKey it will be dropped') : undefined;

history.pushState(state, path);
  }

// deprecated
  function replaceState(state, path) {
    process.env.NODE_ENV !== 'production' ? _warning2['default'](queryKey || state == null, 'You cannot use state without a queryKey it will be dropped') : undefined;

history.replaceState(state, path);
  }

return _extends({}, history, {
    listenBefore: listenBefore,
    listen: listen,
    push: push,
    replace: replace,
    go: go,
    createHref: createHref,

registerTransitionHook: registerTransitionHook, // deprecated - warning is in createHistory
    unregisterTransitionHook: unregisterTransitionHook, // deprecated - warning is in createHistory
    pushState: pushState, // deprecated - warning is in createHistory
    replaceState: replaceState // deprecated - warning is in createHistory
  });
}

exports['default'] = createHashHistory;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 418 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

var _deepEqual = __webpack_require__(844);

var _deepEqual2 = _interopRequireDefault(_deepEqual);

var _PathUtils = __webpack_require__(83);

var _AsyncUtils = __webpack_require__(948);

var _Actions = __webpack_require__(105);

var _createLocation2 = __webpack_require__(950);

var _createLocation3 = _interopRequireDefault(_createLocation2);

var _runTransitionHook = __webpack_require__(269);

var _runTransitionHook2 = _interopRequireDefault(_runTransitionHook);

var _deprecate = __webpack_require__(268);

var _deprecate2 = _interopRequireDefault(_deprecate);

function createRandomKey(length) {
  return Math.random().toString(36).substr(2, length);
}

function locationsAreEqual(a, b) {
  return a.pathname === b.pathname && a.search === b.search &&
  //a.action === b.action && // Different action !== location change.
  a.key === b.key && _deepEqual2['default'](a.state, b.state);
}

var DefaultKeyLength = 6;

function createHistory() {
  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  var getCurrentLocation = options.getCurrentLocation;
  var finishTransition = options.finishTransition;
  var saveState = options.saveState;
  var go = options.go;
  var getUserConfirmation = options.getUserConfirmation;
  var keyLength = options.keyLength;

if (typeof keyLength !== 'number') keyLength = DefaultKeyLength;

var transitionHooks = [];

function listenBefore(hook) {
    transitionHooks.push(hook);

return function () {
      transitionHooks = transitionHooks.filter(function (item) {
        return item !== hook;
      });
    };
  }

var allKeys = [];
  var changeListeners = [];
  var location = undefined;

function updateLocation(newLocation) {
    var current = getCurrent();

location = newLocation;

if (location.action === _Actions.PUSH) {
      allKeys = [].concat(allKeys.slice(0, current + 1), [location.key]);
    } else if (location.action === _Actions.REPLACE) {
      allKeys[current] = location.key;
    }

changeListeners.forEach(function (listener) {
      listener(location);
    });
  }

function listen(listener) {
    changeListeners.push(listener);

if (location) {
      listener(location);
    } else {
      var _location = getCurrentLocation();
      allKeys = [_location.key];
      updateLocation(_location);
    }

return function () {
      changeListeners = changeListeners.filter(function (item) {
        return item !== listener;
      });
    };
  }

var pendingLocation = undefined;

function transitionTo(nextLocation) {
    if (location && locationsAreEqual(location, nextLocation)) return; // Nothing to do.

pendingLocation = nextLocation;

confirmTransitionTo(nextLocation, function (ok) {
      if (pendingLocation !== nextLocation) return; // Transition was interrupted.

if (ok) {
        // treat PUSH to current path like REPLACE to be consistent with browsers
        if (nextLocation.action === _Actions.PUSH) {
          var prevPath = createPath(location);
          var nextPath = createPath(nextLocation);

if (nextPath === prevPath && _deepEqual2['default'](location.state, nextLocation.state)) nextLocation.action = _Actions.REPLACE;
        }

if (finishTransition(nextLocation) !== false) updateLocation(nextLocation);
      } else if (location && nextLocation.action === _Actions.POP) {
        var prevIndex = allKeys.indexOf(location.key);
        var nextIndex = allKeys.indexOf(nextLocation.key);

if (prevIndex !== -1 && nextIndex !== -1) go(prevIndex - nextIndex); // Restore the URL.
      }
    });
  }

function push(location) {
    transitionTo(createLocation(location, _Actions.PUSH, createKey()));
  }

function replace(location) {
    transitionTo(createLocation(location, _Actions.REPLACE, createKey()));
  }

function goBack() {
    go(-1);
  }

function goForward() {
    go(1);
  }

function createKey() {
    return createRandomKey(keyLength);
  }

function createPath(location) {
    if (location == null || typeof location === 'string') return location;

var pathname = location.pathname;
    var search = location.search;
    var hash = location.hash;

var result = pathname;

if (search) result += search;

if (hash) result += hash;

return result;
  }

function createHref(location) {
    return createPath(location);
  }

function createLocation(location, action) {
    var key = arguments.length <= 2 || arguments[2] === undefined ? createKey() : arguments[2];

if (typeof action === 'object') {
      process.env.NODE_ENV !== 'production' ? _warning2['default'](false, 'The state (2nd) argument to history.createLocation is deprecated; use a ' + 'location descriptor instead') : undefined;

if (typeof location === 'string') location = _PathUtils.parsePath(location);

location = _extends({}, location, { state: action });

action = key;
      key = arguments[3] || createKey();
    }

return _createLocation3['default'](location, action, key);
  }

// deprecated
  function setState(state) {
    if (location) {
      updateLocationState(location, state);
      updateLocation(location);
    } else {
      updateLocationState(getCurrentLocation(), state);
    }
  }

function updateLocationState(location, state) {
    location.state = _extends({}, location.state, state);
    saveState(location.key, location.state);
  }

// deprecated
  function registerTransitionHook(hook) {
    if (transitionHooks.indexOf(hook) === -1) transitionHooks.push(hook);
  }

// deprecated
  function unregisterTransitionHook(hook) {
    transitionHooks = transitionHooks.filter(function (item) {
      return item !== hook;
    });
  }

// deprecated
  function pushState(state, path) {
    if (typeof path === 'string') path = _PathUtils.parsePath(path);

push(_extends({ state: state }, path));
  }

// deprecated
  function replaceState(state, path) {
    if (typeof path === 'string') path = _PathUtils.parsePath(path);

replace(_extends({ state: state }, path));
  }

return {
    listenBefore: listenBefore,
    listen: listen,
    transitionTo: transitionTo,
    push: push,
    replace: replace,
    go: go,
    goBack: goBack,
    goForward: goForward,
    createKey: createKey,
    createPath: createPath,
    createHref: createHref,
    createLocation: createLocation,

setState: _deprecate2['default'](setState, 'setState is deprecated; use location.key to save state instead'),
    registerTransitionHook: _deprecate2['default'](registerTransitionHook, 'registerTransitionHook is deprecated; use listenBefore instead'),
    unregisterTransitionHook: _deprecate2['default'](unregisterTransitionHook, 'unregisterTransitionHook is deprecated; use the callback returned from listenBefore instead'),
    pushState: _deprecate2['default'](pushState, 'pushState is deprecated; use push instead'),
    replaceState: _deprecate2['default'](replaceState, 'replaceState is deprecated; use replace instead')
  };
}

exports['default'] = createHistory;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 419 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

var _ExecutionEnvironment = __webpack_require__(169);

var _PathUtils = __webpack_require__(83);

var _runTransitionHook = __webpack_require__(269);

var _runTransitionHook2 = _interopRequireDefault(_runTransitionHook);

var _deprecate = __webpack_require__(268);

var _deprecate2 = _interopRequireDefault(_deprecate);

function useBasename(createHistory) {
  return function () {
    var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

var history = createHistory(options);

var basename = options.basename;

var checkedBaseHref = false;

function checkBaseHref() {
      if (checkedBaseHref) {
        return;
      }

// Automatically use the value of <base href> in HTML
      // documents as basename if it's not explicitly given.
      if (basename == null && _ExecutionEnvironment.canUseDOM) {
        var base = document.getElementsByTagName('base')[0];
        var baseHref = base && base.getAttribute('href');

if (baseHref != null) {
          basename = baseHref;

process.env.NODE_ENV !== 'production' ? _warning2['default'](false, 'Automatically setting basename using <base href> is deprecated and will ' + 'be removed in the next major release. The semantics of <base href> are ' + 'subtly different from basename. Please pass the basename explicitly in ' + 'the options to createHistory') : undefined;
        }
      }

checkedBaseHref = true;
    }

function addBasename(location) {
      checkBaseHref();

if (basename && location.basename == null) {
        if (location.pathname.indexOf(basename) === 0) {
          location.pathname = location.pathname.substring(basename.length);
          location.basename = basename;

if (location.pathname === '') location.pathname = '/';
        } else {
          location.basename = '';
        }
      }

return location;
    }

function prependBasename(location) {
      checkBaseHref();

if (!basename) return location;

if (typeof location === 'string') location = _PathUtils.parsePath(location);

var pname = location.pathname;
      var normalizedBasename = basename.slice(-1) === '/' ? basename : basename + '/';
      var normalizedPathname = pname.charAt(0) === '/' ? pname.slice(1) : pname;
      var pathname = normalizedBasename + normalizedPathname;

return _extends({}, location, {
        pathname: pathname
      });
    }

// Override all read methods with basename-aware versions.
    function listenBefore(hook) {
      return history.listenBefore(function (location, callback) {
        _runTransitionHook2['default'](hook, addBasename(location), callback);
      });
    }

function listen(listener) {
      return history.listen(function (location) {
        listener(addBasename(location));
      });
    }

// Override all write methods with basename-aware versions.
    function push(location) {
      history.push(prependBasename(location));
    }

function replace(location) {
      history.replace(prependBasename(location));
    }

function createPath(location) {
      return history.createPath(prependBasename(location));
    }

function createHref(location) {
      return history.createHref(prependBasename(location));
    }

function createLocation(location) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

return addBasename(history.createLocation.apply(history, [prependBasename(location)].concat(args)));
    }

// deprecated
    function pushState(state, path) {
      if (typeof path === 'string') path = _PathUtils.parsePath(path);

push(_extends({ state: state }, path));
    }

// deprecated
    function replaceState(state, path) {
      if (typeof path === 'string') path = _PathUtils.parsePath(path);

replace(_extends({ state: state }, path));
    }

exports['default'] = useBasename;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 420 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(85),
    root = __webpack_require__(45);

/* Built-in method references that are verified to be native. */
var Set = getNative(root, 'Set');

module.exports = Set;

/***/ }),
/* 421 */
/***/ (function(module, exports, __webpack_require__) {

var root = __webpack_require__(45);

/** Built-in value references. */
var Uint8Array = root.Uint8Array;

module.exports = Uint8Array;

/***/ }),
/* 422 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(85),
    root = __webpack_require__(45);

/* Built-in method references that are verified to be native. */
var WeakMap = getNative(root, 'WeakMap');

module.exports = WeakMap;

/***/ }),
/* 423 */
/***/ (function(module, exports) {

/**
 * A specialized version of `_.forEach` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns `array`.
 */
function arrayEach(array, iteratee) {
  var index = -1,
      length = array == null ? 0 : array.length;

while (++index < length) {
    if (iteratee(array[index], index, array) === false) {
      break;
    }
  }
  return array;
}

module.exports = arrayEach;

/***/ }),
/* 424 */
/***/ (function(module, exports) {

/**
 * A specialized version of `_.filter` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {Array} Returns the new filtered array.
 */
function arrayFilter(array, predicate) {
  var index = -1,
      length = array == null ? 0 : array.length,
      resIndex = 0,
      result = [];

while (++index < length) {
    var value = array[index];
    if (predicate(value, index, array)) {
      result[resIndex++] = value;
    }
  }
  return result;
}

module.exports = arrayFilter;

/***/ }),
/* 425 */
/***/ (function(module, exports, __webpack_require__) {

var baseTimes = __webpack_require__(997),
    isArguments = __webpack_require__(179),
    isArray = __webpack_require__(27),
    isBuffer = __webpack_require__(181),
    isIndex = __webpack_require__(287),
    isTypedArray = __webpack_require__(294);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Creates an array of the enumerable property names of the array-like `value`.
 *
 * @private
 * @param {*} value The value to query.
 * @param {boolean} inherited Specify returning inherited property names.
 * @returns {Array} Returns the array of property names.
 */
function arrayLikeKeys(value, inherited) {
  var isArr = isArray(value),
      isArg = !isArr && isArguments(value),
      isBuff = !isArr && !isArg && isBuffer(value),
      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
      skipIndexes = isArr || isArg || isBuff || isType,
      result = skipIndexes ? baseTimes(value.length, String) : [],
      length = result.length;

for (var key in value) {
    if ((inherited || hasOwnProperty.call(value, key)) &&
        !(skipIndexes && (
           // Safari 9 has enumerable `arguments.length` in strict mode.
           key == 'length' ||
           // Node.js 0.10 has enumerable non-index properties on buffers.
           (isBuff && (key == 'offset' || key == 'parent')) ||
           // PhantomJS 2 has enumerable non-index properties on typed arrays.
           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
           // Skip index properties.
           isIndex(key, length)
        ))) {
      result.push(key);
    }
  }
  return result;
}

module.exports = arrayLikeKeys;

/***/ }),
/* 426 */
/***/ (function(module, exports, __webpack_require__) {

var defineProperty = __webpack_require__(437);

/**
 * The base implementation of `assignValue` and `assignMergeValue` without
 * value checks.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */
function baseAssignValue(object, key, value) {
  if (key == '__proto__' && defineProperty) {
    defineProperty(object, key, {
      'configurable': true,
      'enumerable': true,
      'value': value,
      'writable': true
    });
  } else {
    object[key] = value;
  }
}

module.exports = baseAssignValue;

/***/ }),
/* 427 */
/***/ (function(module, exports, __webpack_require__) {

var Stack = __webpack_require__(274),
    arrayEach = __webpack_require__(423),
    assignValue = __webpack_require__(278),
    baseAssign = __webpack_require__(973),
    baseAssignIn = __webpack_require__(974),
    cloneBuffer = __webpack_require__(1004),
    copyArray = __webpack_require__(436),
    copySymbols = __webpack_require__(1009),
    copySymbolsIn = __webpack_require__(1010),
    getAllKeys = __webpack_require__(441),
    getAllKeysIn = __webpack_require__(442),
    getTag = __webpack_require__(133),
    initCloneArray = __webpack_require__(1033),
    initCloneByTag = __webpack_require__(1034),
    initCloneObject = __webpack_require__(1035),
    isArray = __webpack_require__(27),
    isBuffer = __webpack_require__(181),
    isMap = __webpack_require__(1086),
    isObject = __webpack_require__(46),
    isSet = __webpack_require__(1087),
    keys = __webpack_require__(110),
    keysIn = __webpack_require__(184);

/** Used to compose bitmasks for cloning. */
var CLONE_DEEP_FLAG = 1,
    CLONE_FLAT_FLAG = 2,
    CLONE_SYMBOLS_FLAG = 4;

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    objectTag = '[object Object]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    symbolTag = '[object Symbol]',
    weakMapTag = '[object WeakMap]';

var arrayBufferTag = '[object ArrayBuffer]',
    dataViewTag = '[object DataView]',
    float32Tag = '[object Float32Array]',
    float64Tag = '[object Float64Array]',
    int8Tag = '[object Int8Array]',
    int16Tag = '[object Int16Array]',
    int32Tag = '[object Int32Array]',
    uint8Tag = '[object Uint8Array]',
    uint8ClampedTag = '[object Uint8ClampedArray]',
    uint16Tag = '[object Uint16Array]',
    uint32Tag = '[object Uint32Array]';

/** Used to identify `toStringTag` values supported by `_.clone`. */
var cloneableTags = {};
cloneableTags[argsTag] = cloneableTags[arrayTag] =
cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
cloneableTags[boolTag] = cloneableTags[dateTag] =
cloneableTags[float32Tag] = cloneableTags[float64Tag] =
cloneableTags[int8Tag] = cloneableTags[int16Tag] =
cloneableTags[int32Tag] = cloneableTags[mapTag] =
cloneableTags[numberTag] = cloneableTags[objectTag] =
cloneableTags[regexpTag] = cloneableTags[setTag] =
cloneableTags[stringTag] = cloneableTags[symbolTag] =
cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
cloneableTags[errorTag] = cloneableTags[funcTag] =
cloneableTags[weakMapTag] = false;

/**
 * The base implementation of `_.clone` and `_.cloneDeep` which tracks
 * traversed objects.
 *
 * @private
 * @param {*} value The value to clone.
 * @param {boolean} bitmask The bitmask flags.
 *  1 - Deep clone
 *  2 - Flatten inherited properties
 *  4 - Clone symbols
 * @param {Function} [customizer] The function to customize cloning.
 * @param {string} [key] The key of `value`.
 * @param {Object} [object] The parent object of `value`.
 * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
 * @returns {*} Returns the cloned value.
 */
function baseClone(value, bitmask, customizer, key, object, stack) {
  var result,
      isDeep = bitmask & CLONE_DEEP_FLAG,
      isFlat = bitmask & CLONE_FLAT_FLAG,
      isFull = bitmask & CLONE_SYMBOLS_FLAG;

if (customizer) {
    result = object ? customizer(value, key, object, stack) : customizer(value);
  }
  if (result !== undefined) {
    return result;
  }
  if (!isObject(value)) {
    return value;
  }
  var isArr = isArray(value);
  if (isArr) {
    result = initCloneArray(value);
    if (!isDeep) {
      return copyArray(value, result);
    }
  } else {
    var tag = getTag(value),
        isFunc = tag == funcTag || tag == genTag;

if (isBuffer(value)) {
      return cloneBuffer(value, isDeep);
    }
    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
      result = (isFlat || isFunc) ? {} : initCloneObject(value);
      if (!isDeep) {
        return isFlat
          ? copySymbolsIn(value, baseAssignIn(result, value))
          : copySymbols(value, baseAssign(result, value));
      }
    } else {
      if (!cloneableTags[tag]) {
        return object ? value : {};
      }
      result = initCloneByTag(value, tag, isDeep);
    }
  }
  // Check for circular references and return its corresponding clone.
  stack || (stack = new Stack);
  var stacked = stack.get(value);
  if (stacked) {
    return stacked;
  }
  stack.set(value, result);

if (isSet(value)) {
    value.forEach(function(subValue) {
      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
    });
  } else if (isMap(value)) {
    value.forEach(function(subValue, key) {
      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
    });
  }

var keysFunc = isFull
    ? (isFlat ? getAllKeysIn : getAllKeys)
    : (isFlat ? keysIn : keys);

var props = isArr ? undefined : keysFunc(value);
  arrayEach(props || value, function(subValue, key) {
    if (props) {
      key = subValue;
      subValue = value[key];
    }
    // Recursively populate clone (susceptible to call stack limits).
    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
  });
  return result;
}

module.exports = baseClone;

/***/ }),
/* 428 */
/***/ (function(module, exports, __webpack_require__) {

var SetCache = __webpack_require__(172),
    arrayIncludes = __webpack_require__(275),
    arrayIncludesWith = __webpack_require__(276),
    arrayMap = __webpack_require__(107),
    baseUnary = __webpack_require__(132),
    cacheHas = __webpack_require__(174);

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/**
 * The base implementation of methods like `_.difference` without support
 * for excluding multiple arrays or iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Array} values The values to exclude.
 * @param {Function} [iteratee] The iteratee invoked per element.
 * @param {Function} [comparator] The comparator invoked per element.
 * @returns {Array} Returns the new array of filtered values.
 */
function baseDifference(array, values, iteratee, comparator) {
  var index = -1,
      includes = arrayIncludes,
      isCommon = true,
      length = array.length,
      result = [],
      valuesLength = values.length;

if (!length) {
    return result;
  }
  if (iteratee) {
    values = arrayMap(values, baseUnary(iteratee));
  }
  if (comparator) {
    includes = arrayIncludesWith;
    isCommon = false;
  }
  else if (values.length >= LARGE_ARRAY_SIZE) {
    includes = cacheHas;
    isCommon = false;
    values = new SetCache(values);
  }
  outer:
  while (++index < length) {
    var value = array[index],
        computed = iteratee == null ? value : iteratee(value);

value = (comparator || value !== 0) ? value : 0;
    if (isCommon && computed === computed) {
      var valuesIndex = valuesLength;
      while (valuesIndex--) {
        if (values[valuesIndex] === computed) {
          continue outer;
        }
      }
      result.push(value);
    }
    else if (!includes(values, computed, comparator)) {
      result.push(value);
    }
  }
  return result;
}

module.exports = baseDifference;

/***/ }),
/* 429 */
/***/ (function(module, exports, __webpack_require__) {

var baseForOwn = __webpack_require__(430),
    createBaseEach = __webpack_require__(1013);

/**
 * The base implementation of `_.forEach` without support for iteratee shorthands.
 *
 * @private
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array|Object} Returns `collection`.
 */
var baseEach = createBaseEach(baseForOwn);

module.exports = baseEach;

/***/ }),
/* 430 */
/***/ (function(module, exports, __webpack_require__) {

var baseFor = __webpack_require__(976),
    keys = __webpack_require__(110);

/**
 * The base implementation of `_.forOwn` without support for iteratee shorthands.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Object} Returns `object`.
 */
function baseForOwn(object, iteratee) {
  return object && baseFor(object, iteratee, keys);
}

module.exports = baseForOwn;

/***/ }),
/* 431 */
/***/ (function(module, exports, __webpack_require__) {

var arrayPush = __webpack_require__(277),
    isArray = __webpack_require__(27);

/**
 * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
 * `keysFunc` and `symbolsFunc` to get the enumerable property names and
 * symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @param {Function} symbolsFunc The function to get the symbols of `object`.
 * @returns {Array} Returns the array of property names and symbols.
 */
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
  var result = keysFunc(object);
  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
}

module.exports = baseGetAllKeys;

/***/ }),
/* 432 */
/***/ (function(module, exports, __webpack_require__) {

var isPrototype = __webpack_require__(134),
    nativeKeys = __webpack_require__(1053);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */
function baseKeys(object) {
  if (!isPrototype(object)) {
    return nativeKeys(object);
  }
  var result = [];
  for (var key in Object(object)) {
    if (hasOwnProperty.call(object, key) && key != 'constructor') {
      result.push(key);
    }
  }
  return result;
}

module.exports = baseKeys;

/***/ }),
/* 433 */
/***/ (function(module, exports) {

/**
 * The base implementation of `_.slice` without an iteratee call guard.
 *
 * @private
 * @param {Array} array The array to slice.
 * @param {number} [start=0] The start position.
 * @param {number} [end=array.length] The end position.
 * @returns {Array} Returns the slice of `array`.
 */
function baseSlice(array, start, end) {
  var index = -1,
      length = array.length;

if (start < 0) {
    start = -start > length ? 0 : (length + start);
  }
  end = end > length ? length : end;
  if (end < 0) {
    end += length;
  }
  length = start > end ? 0 : ((end - start) >>> 0);
  start >>>= 0;

var result = Array(length);
  while (++index < length) {
    result[index] = array[index + start];
  }
  return result;
}

module.exports = baseSlice;

/***/ }),
/* 434 */
/***/ (function(module, exports, __webpack_require__) {

var SetCache = __webpack_require__(172),
    arrayIncludes = __webpack_require__(275),
    arrayIncludesWith = __webpack_require__(276),
    cacheHas = __webpack_require__(174),
    createSet = __webpack_require__(1018),
    setToArray = __webpack_require__(290);

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/**
 * The base implementation of `_.uniqBy` without support for iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Function} [iteratee] The iteratee invoked per element.
 * @param {Function} [comparator] The comparator invoked per element.
 * @returns {Array} Returns the new duplicate free array.
 */
function baseUniq(array, iteratee, comparator) {
  var index = -1,
      includes = arrayIncludes,
      length = array.length,
      isCommon = true,
      result = [],
      seen = result;

if (comparator) {
    isCommon = false;
    includes = arrayIncludesWith;
  }
  else if (length >= LARGE_ARRAY_SIZE) {
    var set = iteratee ? null : createSet(array);
    if (set) {
      return setToArray(set);
    }
    isCommon = false;
    includes = cacheHas;
    seen = new SetCache;
  }
  else {
    seen = iteratee ? [] : result;
  }
  outer:
  while (++index < length) {
    var value = array[index],
        computed = iteratee ? iteratee(value) : value;

value = (comparator || value !== 0) ? value : 0;
    if (isCommon && computed === computed) {
      var seenIndex = seen.length;
      while (seenIndex--) {
        if (seen[seenIndex] === computed) {
          continue outer;
        }
      }
      if (iteratee) {
        seen.push(computed);
      }
      result.push(value);
    }
    else if (!includes(seen, computed, comparator)) {
      if (seen !== result) {
        seen.push(computed);
      }
      result.push(value);
    }
  }
  return result;
}

module.exports = baseUniq;

/***/ }),
/* 435 */
/***/ (function(module, exports, __webpack_require__) {

var identity = __webpack_require__(178);

/**
 * Casts `value` to `identity` if it's not a function.
 *
 * @private
 * @param {*} value The value to inspect.
 * @returns {Function} Returns cast function.
 */
function castFunction(value) {
  return typeof value == 'function' ? value : identity;
}

module.exports = castFunction;

/***/ }),
/* 436 */
/***/ (function(module, exports) {

/**
 * Copies the values of `source` to `array`.
 *
 * @private
 * @param {Array} source The array to copy values from.
 * @param {Array} [array=[]] The array to copy values to.
 * @returns {Array} Returns `array`.
 */
function copyArray(source, array) {
  var index = -1,
      length = source.length;

array || (array = Array(length));
  while (++index < length) {
    array[index] = source[index];
  }
  return array;
}

module.exports = copyArray;

/***/ }),
/* 437 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(85);

var defineProperty = (function() {
  try {
    var func = getNative(Object, 'defineProperty');
    func({}, '', {});
    return func;
  } catch (e) {}
}());

module.exports = defineProperty;

/***/ }),
/* 438 */
/***/ (function(module, exports, __webpack_require__) {

var SetCache = __webpack_require__(172),
    arraySome = __webpack_require__(970),
    cacheHas = __webpack_require__(174);

/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1,
    COMPARE_UNORDERED_FLAG = 2;

/**
 * A specialized version of `baseIsEqualDeep` for arrays with support for
 * partial deep comparisons.
 *
 * @private
 * @param {Array} array The array to compare.
 * @param {Array} other The other array to compare.
 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} stack Tracks traversed `array` and `other` objects.
 * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
 */
function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
      arrLength = array.length,
      othLength = other.length;

if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
    return false;
  }
  // Check that cyclic values are equal.
  var arrStacked = stack.get(array);
  var othStacked = stack.get(other);
  if (arrStacked && othStacked) {
    return arrStacked == other && othStacked == array;
  }
  var index = -1,
      result = true,
      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;

stack.set(array, other);
  stack.set(other, array);

// Ignore non-index properties.
  while (++index < arrLength) {
    var arrValue = array[index],
        othValue = other[index];

if (customizer) {
      var compared = isPartial
        ? customizer(othValue, arrValue, index, other, array, stack)
        : customizer(arrValue, othValue, index, array, other, stack);
    }
    if (compared !== undefined) {
      if (compared) {
        continue;
      }
      result = false;
      break;
    }
    // Recursively compare arrays (susceptible to call stack limits).
    if (seen) {
      if (!arraySome(other, function(othValue, othIndex) {
            if (!cacheHas(seen, othIndex) &&
                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
              return seen.push(othIndex);
            }
          })) {
        result = false;
        break;
      }
    } else if (!(
          arrValue === othValue ||
            equalFunc(arrValue, othValue, bitmask, customizer, stack)
        )) {
      result = false;
      break;
    }
  }
  stack['delete'](array);
  stack['delete'](other);
  return result;
}

module.exports = equalArrays;

/***/ }),
/* 439 */
/***/ (function(module, exports, __webpack_require__) {

var flatten = __webpack_require__(1081),
    overRest = __webpack_require__(451),
    setToString = __webpack_require__(452);

/**
 * A specialized version of `baseRest` which flattens the rest array.
 *
 * @private
 * @param {Function} func The function to apply a rest parameter to.
 * @returns {Function} Returns the new function.
 */
function flatRest(func) {
  return setToString(overRest(func, undefined, flatten), func + '');
}

module.exports = flatRest;

/***/ }),
/* 440 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

module.exports = freeGlobal;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 441 */
/***/ (function(module, exports, __webpack_require__) {

var baseGetAllKeys = __webpack_require__(431),
    getSymbols = __webpack_require__(286),
    keys = __webpack_require__(110);

/**
 * Creates an array of own enumerable property names and symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names and symbols.
 */
function getAllKeys(object) {
  return baseGetAllKeys(object, keys, getSymbols);
}

module.exports = getAllKeys;

/***/ }),
/* 442 */
/***/ (function(module, exports, __webpack_require__) {

var baseGetAllKeys = __webpack_require__(431),
    getSymbolsIn = __webpack_require__(445),
    keysIn = __webpack_require__(184);

/**
 * Creates an array of own and inherited enumerable property names and
 * symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names and symbols.
 */
function getAllKeysIn(object) {
  return baseGetAllKeys(object, keysIn, getSymbolsIn);
}

module.exports = getAllKeysIn;

/***/ }),
/* 443 */
/***/ (function(module, exports, __webpack_require__) {

var metaMap = __webpack_require__(1052),
    noop = __webpack_require__(295);

/**
 * Gets metadata for `func`.
 *
 * @private
 * @param {Function} func The function to query.
 * @returns {*} Returns the metadata for `func`.
 */
var getData = !metaMap ? noop : function(func) {
  return metaMap.get(func);
};

module.exports = getData;

/***/ }),
/* 444 */
/***/ (function(module, exports, __webpack_require__) {

var realNames = __webpack_require__(1057);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Gets the name of `func`.
 *
 * @private
 * @param {Function} func The function to query.
 * @returns {string} Returns the function name.
 */
function getFuncName(func) {
  var result = (func.name + ''),
      array = realNames[result],
      length = hasOwnProperty.call(realNames, result) ? array.length : 0;

while (length--) {
    var data = array[length],
        otherFunc = data.func;
    if (otherFunc == null || otherFunc == func) {
      return data.name;
    }
  }
  return result;
}

module.exports = getFuncName;

/***/ }),
/* 445 */
/***/ (function(module, exports, __webpack_require__) {

var arrayPush = __webpack_require__(277),
    getPrototype = __webpack_require__(285),
    getSymbols = __webpack_require__(286),
    stubArray = __webpack_require__(456);

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeGetSymbols = Object.getOwnPropertySymbols;

/**
 * Creates an array of the own and inherited enumerable symbols of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of symbols.
 */
var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
  var result = [];
  while (object) {
    arrayPush(result, getSymbols(object));
    object = getPrototype(object);
  }
  return result;
};

module.exports = getSymbolsIn;

/***/ }),
/* 446 */
/***/ (function(module, exports) {

/** Used to compose unicode capture groups. */
var rsZWJ = '\\u200d';

/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');

/**
 * Checks if `string` contains Unicode symbols.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {boolean} Returns `true` if a symbol is found, else `false`.
 */
function hasUnicode(string) {
  return reHasUnicode.test(string);
}

module.exports = hasUnicode;

/***/ }),
/* 447 */
/***/ (function(module, exports, __webpack_require__) {

var eq = __webpack_require__(136),
    isArrayLike = __webpack_require__(73),
    isIndex = __webpack_require__(287),
    isObject = __webpack_require__(46);

/**
 * Checks if the given arguments are from an iteratee call.
 *
 * @private
 * @param {*} value The potential iteratee value argument.
 * @param {*} index The potential iteratee index or key argument.
 * @param {*} object The potential iteratee object argument.
 * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
 *  else `false`.
 */
function isIterateeCall(value, index, object) {
  if (!isObject(object)) {
    return false;
  }
  var type = typeof index;
  if (type == 'number'
        ? (isArrayLike(object) && isIndex(index, object.length))
        : (type == 'string' && index in object)
      ) {
    return eq(object[index], value);
  }
  return false;
}

module.exports = isIterateeCall;

/***/ }),
/* 448 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(46);

/**
 * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` if suitable for strict
 *  equality comparisons, else `false`.
 */
function isStrictComparable(value) {
  return value === value && !isObject(value);
}

module.exports = isStrictComparable;

/***/ }),
/* 449 */
/***/ (function(module, exports) {

/**
 * A specialized version of `matchesProperty` for source values suitable
 * for strict equality comparisons, i.e. `===`.
 *
 * @private
 * @param {string} key The key of the property to get.
 * @param {*} srcValue The value to match.
 * @returns {Function} Returns the new spec function.
 */
function matchesStrictComparable(key, srcValue) {
  return function(object) {
    if (object == null) {
      return false;
    }
    return object[key] === srcValue &&
      (srcValue !== undefined || (key in Object(object)));
  };
}

module.exports = matchesStrictComparable;

/***/ }),
/* 450 */
/***/ (function(module, exports) {

/**
 * Creates a unary function that invokes `func` with its argument transformed.
 *
 * @private
 * @param {Function} func The function to wrap.
 * @param {Function} transform The argument transform.
 * @returns {Function} Returns the new function.
 */
function overArg(func, transform) {
  return function(arg) {
    return func(transform(arg));
  };
}

module.exports = overArg;

/***/ }),
/* 451 */
/***/ (function(module, exports, __webpack_require__) {

var apply = __webpack_require__(968);

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max;

/**
 * A specialized version of `baseRest` which transforms the rest array.
 *
 * @private
 * @param {Function} func The function to apply a rest parameter to.
 * @param {number} [start=func.length-1] The start position of the rest parameter.
 * @param {Function} transform The rest array transform.
 * @returns {Function} Returns the new function.
 */
function overRest(func, start, transform) {
  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
  return function() {
    var args = arguments,
        index = -1,
        length = nativeMax(args.length - start, 0),
        array = Array(length);

while (++index < length) {
      array[index] = args[start + index];
    }
    index = -1;
    var otherArgs = Array(start + 1);
    while (++index < start) {
      otherArgs[index] = args[index];
    }
    otherArgs[start] = transform(array);
    return apply(func, this, otherArgs);
  };
}

module.exports = overRest;

/***/ }),
/* 452 */
/***/ (function(module, exports, __webpack_require__) {

var baseSetToString = __webpack_require__(996),
    shortOut = __webpack_require__(1060);

/**
 * Sets the `toString` method of `func` to return `string`.
 *
 * @private
 * @param {Function} func The function to modify.
 * @param {Function} string The `toString` result.
 * @returns {Function} Returns `func`.
 */
var setToString = shortOut(baseSetToString);

module.exports = setToString;

/***/ }),
/* 453 */
/***/ (function(module, exports) {

/** Used for built-in method references. */
var funcProto = Function.prototype;

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/**
 * Converts `func` to its source code.
 *
 * @private
 * @param {Function} func The function to convert.
 * @returns {string} Returns the source code.
 */
function toSource(func) {
  if (func != null) {
    try {
      return funcToString.call(func);
    } catch (e) {}
    try {
      return (func + '');
    } catch (e) {}
  }
  return '';
}

module.exports = toSource;

/***/ }),
/* 454 */
/***/ (function(module, exports, __webpack_require__) {

var baseGetTag = __webpack_require__(84),
    isObject = __webpack_require__(46);

/** `Object#toString` result references. */
var asyncTag = '[object AsyncFunction]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    proxyTag = '[object Proxy]';

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */
function isFunction(value) {
  if (!isObject(value)) {
    return false;
  }
  // The use of `Object#toString` avoids issues with the `typeof` operator
  // in Safari 9 which returns 'object' for typed arrays and other constructors.
  var tag = baseGetTag(value);
  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
}

module.exports = isFunction;

/***/ }),
/* 455 */
/***/ (function(module, exports, __webpack_require__) {

var MapCache = __webpack_require__(273);

/** Error message constants. */
var FUNC_ERROR_TEXT = 'Expected a function';

/**
 * Creates a function that memoizes the result of `func`. If `resolver` is
 * provided, it determines the cache key for storing the result based on the
 * arguments provided to the memoized function. By default, the first argument
 * provided to the memoized function is used as the map cache key. The `func`
 * is invoked with the `this` binding of the memoized function.
 *
 * **Note:** The cache is exposed as the `cache` property on the memoized
 * function. Its creation may be customized by replacing the `_.memoize.Cache`
 * constructor with one whose instances implement the
 * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
 * method interface of `clear`, `delete`, `get`, `has`, and `set`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to have its output memoized.
 * @param {Function} [resolver] The function to resolve the cache key.
 * @returns {Function} Returns the new memoized function.
 * @example
 *
 * var object = { 'a': 1, 'b': 2 };
 * var other = { 'c': 3, 'd': 4 };
 *
 * var values = _.memoize(_.values);
 * values(object);
 * // => [1, 2]
 *
 * values(other);
 * // => [3, 4]
 *
 * object.a = 2;
 * values(object);
 * // => [1, 2]
 *
 * // Modify the result cache.
 * values.cache.set(object, ['a', 'b']);
 * values(object);
 * // => ['a', 'b']
 *
 * // Replace `_.memoize.Cache`.
 * _.memoize.Cache = WeakMap;
 */
function memoize(func, resolver) {
  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  var memoized = function() {
    var args = arguments,
        key = resolver ? resolver.apply(this, args) : args[0],
        cache = memoized.cache;

if (cache.has(key)) {
      return cache.get(key);
    }
    var result = func.apply(this, args);
    memoized.cache = cache.set(key, result) || cache;
    return result;
  };
  memoized.cache = new (memoize.Cache || MapCache);
  return memoized;
}

// Expose `MapCache`.
memoize.Cache = MapCache;

module.exports = memoize;

/***/ }),
/* 456 */
/***/ (function(module, exports) {

/**
 * This method returns a new empty array.
 *
 * @static
 * @memberOf _
 * @since 4.13.0
 * @category Util
 * @returns {Array} Returns the new empty array.
 * @example
 *
 * var arrays = _.times(2, _.stubArray);
 *
 * console.log(arrays);
 * // => [[], []]
 *
 * console.log(arrays[0] === arrays[1]);
 * // => false
 */
function stubArray() {
  return [];
}

module.exports = stubArray;

/***/ }),
/* 457 */
/***/ (function(module, exports, __webpack_require__) {

var baseDifference = __webpack_require__(428),
    baseRest = __webpack_require__(108),
    isArrayLikeObject = __webpack_require__(180);

/**
 * Creates an array excluding all given values using
 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons.
 *
 * **Note:** Unlike `_.pull`, this method returns a new array.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Array
 * @param {Array} array The array to inspect.
 * @param {...*} [values] The values to exclude.
 * @returns {Array} Returns the new array of filtered values.
 * @see _.difference, _.xor
 * @example
 *
 * _.without([2, 1, 2, 3], 1, 2);
 * // => [3]
 */
var without = baseRest(function(array, values) {
  return isArrayLikeObject(array)
    ? baseDifference(array, values)
    : [];
});

module.exports = without;

/***/ }),
/* 458 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "red", function() { return red; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pink", function() { return pink; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "purple", function() { return purple; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "deepPurple", function() { return deepPurple; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "indigo", function() { return indigo; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "blue", function() { return blue; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lightBlue", function() { return lightBlue; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cyan", function() { return cyan; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "teal", function() { return teal; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "green", function() { return green; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lightGreen", function() { return lightGreen; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lime", function() { return lime; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "yellow", function() { return yellow; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "amber", function() { return amber; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "orange", function() { return orange; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "deepOrange", function() { return deepOrange; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "brown", function() { return brown; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "grey", function() { return grey; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "blueGrey", function() { return blueGrey; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "darkText", function() { return darkText; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lightText", function() { return lightText; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "darkIcons", function() { return darkIcons; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lightIcons", function() { return lightIcons; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "white", function() { return white; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "black", function() { return black; });
var red = {"50":"#ffebee","100":"#ffcdd2","200":"#ef9a9a","300":"#e57373","400":"#ef5350","500":"#f44336","600":"#e53935","700":"#d32f2f","800":"#c62828","900":"#b71c1c","a100":"#ff8a80","a200":"#ff5252","a400":"#ff1744","a700":"#d50000"};
var pink = {"50":"#fce4ec","100":"#f8bbd0","200":"#f48fb1","300":"#f06292","400":"#ec407a","500":"#e91e63","600":"#d81b60","700":"#c2185b","800":"#ad1457","900":"#880e4f","a100":"#ff80ab","a200":"#ff4081","a400":"#f50057","a700":"#c51162"};
var purple = {"50":"#f3e5f5","100":"#e1bee7","200":"#ce93d8","300":"#ba68c8","400":"#ab47bc","500":"#9c27b0","600":"#8e24aa","700":"#7b1fa2","800":"#6a1b9a","900":"#4a148c","a100":"#ea80fc","a200":"#e040fb","a400":"#d500f9","a700":"#aa00ff"};
var deepPurple = {"50":"#ede7f6","100":"#d1c4e9","200":"#b39ddb","300":"#9575cd","400":"#7e57c2","500":"#673ab7","600":"#5e35b1","700":"#512da8","800":"#4527a0","900":"#311b92","a100":"#b388ff","a200":"#7c4dff","a400":"#651fff","a700":"#6200ea"};
var indigo = {"50":"#e8eaf6","100":"#c5cae9","200":"#9fa8da","300":"#7986cb","400":"#5c6bc0","500":"#3f51b5","600":"#3949ab","700":"#303f9f","800":"#283593","900":"#1a237e","a100":"#8c9eff","a200":"#536dfe","a400":"#3d5afe","a700":"#304ffe"};
var blue = {"50":"#e3f2fd","100":"#bbdefb","200":"#90caf9","300":"#64b5f6","400":"#42a5f5","500":"#2196f3","600":"#1e88e5","700":"#1976d2","800":"#1565c0","900":"#0d47a1","a100":"#82b1ff","a200":"#448aff","a400":"#2979ff","a700":"#2962ff"};
var lightBlue = {"50":"#e1f5fe","100":"#b3e5fc","200":"#81d4fa","300":"#4fc3f7","400":"#29b6f6","500":"#03a9f4","600":"#039be5","700":"#0288d1","800":"#0277bd","900":"#01579b","a100":"#80d8ff","a200":"#40c4ff","a400":"#00b0ff","a700":"#0091ea"};
var cyan = {"50":"#e0f7fa","100":"#b2ebf2","200":"#80deea","300":"#4dd0e1","400":"#26c6da","500":"#00bcd4","600":"#00acc1","700":"#0097a7","800":"#00838f","900":"#006064","a100":"#84ffff","a200":"#18ffff","a400":"#00e5ff","a700":"#00b8d4"};
var teal = {"50":"#e0f2f1","100":"#b2dfdb","200":"#80cbc4","300":"#4db6ac","400":"#26a69a","500":"#009688","600":"#00897b","700":"#00796b","800":"#00695c","900":"#004d40","a100":"#a7ffeb","a200":"#64ffda","a400":"#1de9b6","a700":"#00bfa5"};
var green = {"50":"#e8f5e9","100":"#c8e6c9","200":"#a5d6a7","300":"#81c784","400":"#66bb6a","500":"#4caf50","600":"#43a047","700":"#388e3c","800":"#2e7d32","900":"#1b5e20","a100":"#b9f6ca","a200":"#69f0ae","a400":"#00e676","a700":"#00c853"};
var lightGreen = {"50":"#f1f8e9","100":"#dcedc8","200":"#c5e1a5","300":"#aed581","400":"#9ccc65","500":"#8bc34a","600":"#7cb342","700":"#689f38","800":"#558b2f","900":"#33691e","a100":"#ccff90","a200":"#b2ff59","a400":"#76ff03","a700":"#64dd17"};
var lime = {"50":"#f9fbe7","100":"#f0f4c3","200":"#e6ee9c","300":"#dce775","400":"#d4e157","500":"#cddc39","600":"#c0ca33","700":"#afb42b","800":"#9e9d24","900":"#827717","a100":"#f4ff81","a200":"#eeff41","a400":"#c6ff00","a700":"#aeea00"};
var yellow = {"50":"#fffde7","100":"#fff9c4","200":"#fff59d","300":"#fff176","400":"#ffee58","500":"#ffeb3b","600":"#fdd835","700":"#fbc02d","800":"#f9a825","900":"#f57f17","a100":"#ffff8d","a200":"#ffff00","a400":"#ffea00","a700":"#ffd600"};
var amber = {"50":"#fff8e1","100":"#ffecb3","200":"#ffe082","300":"#ffd54f","400":"#ffca28","500":"#ffc107","600":"#ffb300","700":"#ffa000","800":"#ff8f00","900":"#ff6f00","a100":"#ffe57f","a200":"#ffd740","a400":"#ffc400","a700":"#ffab00"};
var orange = {"50":"#fff3e0","100":"#ffe0b2","200":"#ffcc80","300":"#ffb74d","400":"#ffa726","500":"#ff9800","600":"#fb8c00","700":"#f57c00","800":"#ef6c00","900":"#e65100","a100":"#ffd180","a200":"#ffab40","a400":"#ff9100","a700":"#ff6d00"};
var deepOrange = {"50":"#fbe9e7","100":"#ffccbc","200":"#ffab91","300":"#ff8a65","400":"#ff7043","500":"#ff5722","600":"#f4511e","700":"#e64a19","800":"#d84315","900":"#bf360c","a100":"#ff9e80","a200":"#ff6e40","a400":"#ff3d00","a700":"#dd2c00"};
var brown = {"50":"#efebe9","100":"#d7ccc8","200":"#bcaaa4","300":"#a1887f","400":"#8d6e63","500":"#795548","600":"#6d4c41","700":"#5d4037","800":"#4e342e","900":"#3e2723"};
var grey = {"50":"#fafafa","100":"#f5f5f5","200":"#eeeeee","300":"#e0e0e0","400":"#bdbdbd","500":"#9e9e9e","600":"#757575","700":"#616161","800":"#424242","900":"#212121"};
var blueGrey = {"50":"#eceff1","100":"#cfd8dc","200":"#b0bec5","300":"#90a4ae","400":"#78909c","500":"#607d8b","600":"#546e7a","700":"#455a64","800":"#37474f","900":"#263238"};
var darkText = {"primary":"rgba(0, 0, 0, 0.87)","secondary":"rgba(0, 0, 0, 0.54)","disabled":"rgba(0, 0, 0, 0.38)","dividers":"rgba(0, 0, 0, 0.12)"};
var lightText = {"primary":"rgba(255, 255, 255, 1)","secondary":"rgba(255, 255, 255, 0.7)","disabled":"rgba(255, 255, 255, 0.5)","dividers":"rgba(255, 255, 255, 0.12)"};
var darkIcons = {"active":"rgba(0, 0, 0, 0.54)","inactive":"rgba(0, 0, 0, 0.38)"};
var lightIcons = {"active":"rgba(255, 255, 255, 1)","inactive":"rgba(255, 255, 255, 0.5)"};
var white = "#ffffff";
var black = "#000000";

/* harmony default export */ __webpack_exports__["default"] = ({
  red: red,
  pink: pink,
  purple: purple,
  deepPurple: deepPurple,
  indigo: indigo,
  blue: blue,
  lightBlue: lightBlue,
  cyan: cyan,
  teal: teal,
  green: green,
  lightGreen: lightGreen,
  lime: lime,
  yellow: yellow,
  amber: amber,
  orange: orange,
  deepOrange: deepOrange,
  brown: brown,
  grey: grey,
  blueGrey: blueGrey,
  darkText: darkText,
  lightText: lightText,
  darkIcons: darkIcons,
  lightIcons: lightIcons,
  white: white,
  black: black
});

/***/ }),
/* 459 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.storeShape = undefined;

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var storeShape = exports.storeShape = _propTypes2.default.shape({
  subscribe: _propTypes2.default.func.isRequired,
  setState: _propTypes2.default.func.isRequired,
  getState: _propTypes2.default.func.isRequired
});

/***/ }),
/* 460 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var numberIsNaN = function (value) {
	return value !== value;
};

module.exports = function is(a, b) {
	if (a === 0 && b === 0) {
		return 1 / a === 1 / b;
	}
	if (a === b) {
		return true;
	}
	if (numberIsNaN(a) && numberIsNaN(b)) {
		return true;
	}
	return false;
};

/***/ }),
/* 461 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var implementation = __webpack_require__(460);

module.exports = function getPolyfill() {
	return typeof Object.is === 'function' ? Object.is : implementation;
};

/***/ }),
/* 462 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var slice = Array.prototype.slice;
var isArgs = __webpack_require__(463);

var origKeys = Object.keys;
var keysShim = origKeys ? function keys(o) { return origKeys(o); } : __webpack_require__(1108);

var originalKeys = Object.keys;

keysShim.shim = function shimObjectKeys() {
	if (Object.keys) {
		var keysWorksWithArguments = (function () {
			// Safari 5.0 bug
			var args = Object.keys(arguments);
			return args && args.length === arguments.length;
		}(1, 2));
		if (!keysWorksWithArguments) {
			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
				if (isArgs(object)) {
					return originalKeys(slice.call(object));
				}
				return originalKeys(object);
			};
		}
	} else {
		Object.keys = keysShim;
	}
	return Object.keys || keysShim;
};

module.exports = keysShim;

/***/ }),
/* 463 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var toStr = Object.prototype.toString;

module.exports = function isArguments(value) {
	var str = toStr.call(value);
	var isArgs = str === '[object Arguments]';
	if (!isArgs) {
		isArgs = str !== '[object Array]' &&
			value !== null &&
			typeof value === 'object' &&
			typeof value.length === 'number' &&
			value.length >= 0 &&
			toStr.call(value.callee) === '[object Function]';
	}
	return isArgs;
};

/***/ }),
/* 464 */
/***/ (function(module, exports) {

module.exports = Function.call.bind(Object.prototype.hasOwnProperty);

/***/ }),
/* 465 */
/***/ (function(module, exports) {

var component = /-?\d+(\.\d+)?%?/g;
function extractComponents(color) {
  return color.match(component);
}

module.exports = extractComponents;

/***/ }),
/* 466 */
/***/ (function(module, exports) {

function clamp(val, min, max) {
  return Math.min(Math.max(val, min), max);
}

module.exports = clamp;

/***/ }),
/* 467 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
var util = {
  isAppearSupported: function isAppearSupported(props) {
    return props.transitionName && props.transitionAppear || props.animation.appear;
  },
  isEnterSupported: function isEnterSupported(props) {
    return props.transitionName && props.transitionEnter || props.animation.enter;
  },
  isLeaveSupported: function isLeaveSupported(props) {
    return props.transitionName && props.transitionLeave || props.animation.leave;
  },
  allowAppearCallback: function allowAppearCallback(props) {
    return props.transitionAppear || props.animation.appear;
  },
  allowEnterCallback: function allowEnterCallback(props) {
    return props.transitionEnter || props.animation.enter;
  },
  allowLeaveCallback: function allowLeaveCallback(props) {
    return props.transitionLeave || props.animation.leave;
  }
};
/* harmony default export */ __webpack_exports__["a"] = (util);

/***/ }),
/* 468 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Checkbox__ = __webpack_require__(1130);

/* harmony default export */ __webpack_exports__["a"] = (__WEBPACK_IMPORTED_MODULE_0__Checkbox__["a" /* default */]);

/***/ }),
/* 469 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export SubMenu */
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rc_trigger__ = __webpack_require__(301);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rc_util_es_KeyCode__ = __webpack_require__(87);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rc_animate__ = __webpack_require__(139);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_mini_store__ = __webpack_require__(185);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_mini_store___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_mini_store__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__SubPopupMenu__ = __webpack_require__(470);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__placements__ = __webpack_require__(1146);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__util__ = __webpack_require__(111);
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var guid = 0;
var popupPlacementMap = {
  horizontal: 'bottomLeft',
  vertical: 'rightTop',
  'vertical-left': 'rightTop',
  'vertical-right': 'leftTop'
};

var SubMenu =
/*#__PURE__*/
function (_React$Component) {
  _inherits(SubMenu, _React$Component);

function SubMenu(props) {
    var _this;

_classCallCheck(this, SubMenu);

_this = _possibleConstructorReturn(this, _getPrototypeOf(SubMenu).call(this, props));

_this.onDestroy = function (key) {
      _this.props.onDestroy(key);
    };
    /**
     * note:
     *  This legacy code that `onKeyDown` is called by parent instead of dom self.
     *  which need return code to check if this event is handled
     */

_this.onKeyDown = function (e) {
      var keyCode = e.keyCode;
      var menu = _this.menuInstance;
      var _this$props = _this.props,
          isOpen = _this$props.isOpen,
          store = _this$props.store;

if (keyCode === __WEBPACK_IMPORTED_MODULE_3_rc_util_es_KeyCode__["a" /* default */].ENTER) {
        _this.onTitleClick(e);

updateDefaultActiveFirst(store, _this.props.eventKey, true);
        return true;
      }

if (keyCode === __WEBPACK_IMPORTED_MODULE_3_rc_util_es_KeyCode__["a" /* default */].RIGHT) {
        if (isOpen) {
          menu.onKeyDown(e);
        } else {
          _this.triggerOpenChange(true); // need to update current menu's defaultActiveFirst value

updateDefaultActiveFirst(store, _this.props.eventKey, true);
        }

return true;
      }

if (keyCode === __WEBPACK_IMPORTED_MODULE_3_rc_util_es_KeyCode__["a" /* default */].LEFT) {
        var handled;

if (isOpen) {
          handled = menu.onKeyDown(e);
        } else {
          return undefined;
        }

if (!handled) {
          _this.triggerOpenChange(false);

handled = true;
        }

return handled;
      }

if (isOpen && (keyCode === __WEBPACK_IMPORTED_MODULE_3_rc_util_es_KeyCode__["a" /* default */].UP || keyCode === __WEBPACK_IMPORTED_MODULE_3_rc_util_es_KeyCode__["a" /* default */].DOWN)) {
        return menu.onKeyDown(e);
      }

return undefined;
    };

_this.onOpenChange = function (e) {
      _this.props.onOpenChange(e);
    };

_this.onPopupVisibleChange = function (visible) {
      _this.triggerOpenChange(visible, visible ? 'mouseenter' : 'mouseleave');
    };

_this.onMouseEnter = function (e) {
      var _this$props2 = _this.props,
          key = _this$props2.eventKey,
          onMouseEnter = _this$props2.onMouseEnter,
          store = _this$props2.store;
      updateDefaultActiveFirst(store, _this.props.eventKey, false);
      onMouseEnter({
        key: key,
        domEvent: e
      });
    };

_this.onMouseLeave = function (e) {
      var _this$props3 = _this.props,
          parentMenu = _this$props3.parentMenu,
          eventKey = _this$props3.eventKey,
          onMouseLeave = _this$props3.onMouseLeave;
      parentMenu.subMenuInstance = _assertThisInitialized(_this);
      onMouseLeave({
        key: eventKey,
        domEvent: e
      });
    };

_this.onTitleMouseEnter = function (domEvent) {
      var _this$props4 = _this.props,
          key = _this$props4.eventKey,
          onItemHover = _this$props4.onItemHover,
          onTitleMouseEnter = _this$props4.onTitleMouseEnter;
      onItemHover({
        key: key,
        hover: true
      });
      onTitleMouseEnter({
        key: key,
        domEvent: domEvent
      });
    };

_this.onTitleMouseLeave = function (e) {
      var _this$props5 = _this.props,
          parentMenu = _this$props5.parentMenu,
          eventKey = _this$props5.eventKey,
          onItemHover = _this$props5.onItemHover,
          onTitleMouseLeave = _this$props5.onTitleMouseLeave;
      parentMenu.subMenuInstance = _assertThisInitialized(_this);
      onItemHover({
        key: eventKey,
        hover: false
      });
      onTitleMouseLeave({
        key: eventKey,
        domEvent: e
      });
    };

_this.onTitleClick = function (e) {
      var _assertThisInitialize = _assertThisInitialized(_this),
          props = _assertThisInitialize.props;

props.onTitleClick({
        key: props.eventKey,
        domEvent: e
      });

if (props.triggerSubMenuAction === 'hover') {
        return;
      }

_this.triggerOpenChange(!props.isOpen, 'click');

updateDefaultActiveFirst(props.store, _this.props.eventKey, false);
    };

_this.onSubMenuClick = function (info) {
      // in the case of overflowed submenu
      // onClick is not copied over
      if (typeof _this.props.onClick === 'function') {
        _this.props.onClick(_this.addKeyPath(info));
      }
    };

_this.onSelect = function (info) {
      _this.props.onSelect(info);
    };

_this.onDeselect = function (info) {
      _this.props.onDeselect(info);
    };

_this.getPrefixCls = function () {
      return "".concat(_this.props.rootPrefixCls, "-submenu");
    };

_this.getActiveClassName = function () {
      return "".concat(_this.getPrefixCls(), "-active");
    };

_this.getDisabledClassName = function () {
      return "".concat(_this.getPrefixCls(), "-disabled");
    };

_this.getSelectedClassName = function () {
      return "".concat(_this.getPrefixCls(), "-selected");
    };

_this.getOpenClassName = function () {
      return "".concat(_this.props.rootPrefixCls, "-submenu-open");
    };

_this.saveMenuInstance = function (c) {
      // children menu instance
      _this.menuInstance = c;
    };

_this.addKeyPath = function (info) {
      return _objectSpread({}, info, {
        keyPath: (info.keyPath || []).concat(_this.props.eventKey)
      });
    };

_this.triggerOpenChange = function (open, type) {
      var key = _this.props.eventKey;

var openChange = function openChange() {
        _this.onOpenChange({
          key: key,
          item: _assertThisInitialized(_this),
          trigger: type,
          open: open
        });
      };

if (type === 'mouseenter') {
        // make sure mouseenter happen after other menu item's mouseleave
        _this.mouseenterTimeout = setTimeout(function () {
          openChange();
        }, 0);
      } else {
        openChange();
      }
    };

_this.isChildrenSelected = function () {
      var ret = {
        find: false
      };
      __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["i" /* loopMenuItemRecursively */])(_this.props.children, _this.props.selectedKeys, ret);
      return ret.find;
    };

_this.isOpen = function () {
      return _this.props.openKeys.indexOf(_this.props.eventKey) !== -1;
    };

_this.adjustWidth = function () {
      /* istanbul ignore if */
      if (!_this.subMenuTitle || !_this.menuInstance) {
        return;
      }

var popupMenu = __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.findDOMNode(_this.menuInstance);

if (popupMenu.offsetWidth >= _this.subMenuTitle.offsetWidth) {
        return;
      }
      /* istanbul ignore next */

popupMenu.style.minWidth = "".concat(_this.subMenuTitle.offsetWidth, "px");
    };

_this.saveSubMenuTitle = function (subMenuTitle) {
      _this.subMenuTitle = subMenuTitle;
    };

var store = props.store,
        eventKey = props.eventKey;

var _store$getState = store.getState(),
        defaultActiveFirst = _store$getState.defaultActiveFirst;

_this.isRootMenu = false;
    var value = false;

if (defaultActiveFirst) {
      value = defaultActiveFirst[eventKey];
    }

updateDefaultActiveFirst(store, eventKey, value);
    return _this;
  }

_createClass(SubMenu, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.componentDidUpdate();
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate() {
      var _this2 = this;

var _this$props6 = this.props,
          mode = _this$props6.mode,
          parentMenu = _this$props6.parentMenu,
          manualRef = _this$props6.manualRef; // invoke customized ref to expose component to mixin

if (manualRef) {
        manualRef(this);
      }

if (mode !== 'horizontal' || !parentMenu.isRootMenu || !this.props.isOpen) {
        return;
      }

this.minWidthTimeout = setTimeout(function () {
        return _this2.adjustWidth();
      }, 0);
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      var _this$props7 = this.props,
          onDestroy = _this$props7.onDestroy,
          eventKey = _this$props7.eventKey;

if (onDestroy) {
        onDestroy(eventKey);
      }
      /* istanbul ignore if */

if (this.minWidthTimeout) {
        clearTimeout(this.minWidthTimeout);
      }
      /* istanbul ignore if */

if (this.mouseenterTimeout) {
        clearTimeout(this.mouseenterTimeout);
      }
    }
  }, {
    key: "renderChildren",
    value: function renderChildren(children) {
      var props = this.props;
      var baseProps = {
        mode: props.mode === 'horizontal' ? 'vertical' : props.mode,
        visible: this.props.isOpen,
        level: props.level + 1,
        inlineIndent: props.inlineIndent,
        focusable: false,
        onClick: this.onSubMenuClick,
        onSelect: this.onSelect,
        onDeselect: this.onDeselect,
        onDestroy: this.onDestroy,
        selectedKeys: props.selectedKeys,
        eventKey: "".concat(props.eventKey, "-menu-"),
        openKeys: props.openKeys,
        openTransitionName: props.openTransitionName,
        openAnimation: props.openAnimation,
        onOpenChange: this.onOpenChange,
        subMenuOpenDelay: props.subMenuOpenDelay,
        parentMenu: this,
        subMenuCloseDelay: props.subMenuCloseDelay,
        forceSubMenuRender: props.forceSubMenuRender,
        triggerSubMenuAction: props.triggerSubMenuAction,
        builtinPlacements: props.builtinPlacements,
        defaultActiveFirst: props.store.getState().defaultActiveFirst[__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["h" /* getMenuIdFromSubMenuEventKey */])(props.eventKey)],
        multiple: props.multiple,
        prefixCls: props.rootPrefixCls,
        id: this.internalMenuId,
        manualRef: this.saveMenuInstance,
        itemIcon: props.itemIcon,
        expandIcon: props.expandIcon
      };
      var haveRendered = this.haveRendered;
      this.haveRendered = true;
      this.haveOpened = this.haveOpened || baseProps.visible || baseProps.forceSubMenuRender; // never rendered not planning to, don't render

if (!this.haveOpened) {
        return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("div", null);
      } // don't show transition on first rendering (no animation for opened menu)
      // show appear transition if it's not visible (not sure why)
      // show appear transition if it's not inline mode

var transitionAppear = haveRendered || !baseProps.visible || baseProps.mode !== 'inline';
      baseProps.className = " ".concat(baseProps.prefixCls, "-sub");
      var animProps = {};

if (baseProps.openTransitionName) {
        animProps.transitionName = baseProps.openTransitionName;
      } else if (_typeof(baseProps.openAnimation) === 'object') {
        animProps.animation = _objectSpread({}, baseProps.openAnimation);

if (!transitionAppear) {
          delete animProps.animation.appear;
        }
      }

return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_4_rc_animate__["a" /* default */], Object.assign({}, animProps, {
        showProp: "visible",
        component: "",
        transitionAppear: transitionAppear
      }), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_7__SubPopupMenu__["b" /* default */], Object.assign({}, baseProps, {
        id: this.internalMenuId
      }), children));
    }
  }, {
    key: "render",
    value: function render() {
      var _classNames;

var props = _objectSpread({}, this.props);

var isOpen = props.isOpen;
      var prefixCls = this.getPrefixCls();
      var isInlineMode = props.mode === 'inline';
      var className = __WEBPACK_IMPORTED_MODULE_5_classnames___default()(prefixCls, "".concat(prefixCls, "-").concat(props.mode), (_classNames = {}, _defineProperty(_classNames, props.className, !!props.className), _defineProperty(_classNames, this.getOpenClassName(), isOpen), _defineProperty(_classNames, this.getActiveClassName(), props.active || isOpen && !isInlineMode), _defineProperty(_classNames, this.getDisabledClassName(), props.disabled), _defineProperty(_classNames, this.getSelectedClassName(), this.isChildrenSelected()), _classNames));

if (!this.internalMenuId) {
        if (props.eventKey) {
          this.internalMenuId = "".concat(props.eventKey, "$Menu");
        } else {
          guid += 1;
          this.internalMenuId = "$__$".concat(guid, "$Menu");
        }
      }

var mouseEvents = {};
      var titleClickEvents = {};
      var titleMouseEvents = {};

if (!props.disabled) {
        mouseEvents = {
          onMouseLeave: this.onMouseLeave,
          onMouseEnter: this.onMouseEnter
        }; // only works in title, not outer li

titleClickEvents = {
          onClick: this.onTitleClick
        };
        titleMouseEvents = {
          onMouseEnter: this.onTitleMouseEnter,
          onMouseLeave: this.onTitleMouseLeave
        };
      }

var style = {};

if (isInlineMode) {
        style.paddingLeft = props.inlineIndent * props.level;
      }

var ariaOwns = {}; // only set aria-owns when menu is open
      // otherwise it would be an invalid aria-owns value
      // since corresponding node cannot be found

if (this.props.isOpen) {
        ariaOwns = {
          'aria-owns': this.internalMenuId
        };
      } // expand custom icon should NOT be displayed in menu with horizontal mode.

var icon = null;

if (props.mode !== 'horizontal') {
        icon = this.props.expandIcon; // ReactNode

if (typeof this.props.expandIcon === 'function') {
          icon = __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(this.props.expandIcon, _objectSpread({}, this.props));
        }
      }

delete props.onClick;
      return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("li", Object.assign({}, props, mouseEvents, {
        className: className,
        role: "menuitem"
      }), isInlineMode && title, isInlineMode && children, !isInlineMode && __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2_rc_trigger__["a" /* default */], {
        prefixCls: prefixCls,
        popupClassName: "".concat(prefixCls, "-popup ").concat(popupClassName),
        getPopupContainer: getPopupContainer,
        builtinPlacements: Object.assign({}, __WEBPACK_IMPORTED_MODULE_8__placements__["a" /* default */], builtinPlacements),
        popupPlacement: popupPlacement,
        popupVisible: isOpen,
        popupAlign: popupAlign,
        popup: children,
        action: disabled ? [] : [triggerSubMenuAction],
        mouseEnterDelay: subMenuOpenDelay,
        mouseLeaveDelay: subMenuCloseDelay,
        onPopupVisibleChange: this.onPopupVisibleChange,
        forceRender: forceSubMenuRender
      }, title));
    }
  }]);

return SubMenu;
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);
SubMenu.defaultProps = {
  onMouseEnter: __WEBPACK_IMPORTED_MODULE_9__util__["a" /* noop */],
  onMouseLeave: __WEBPACK_IMPORTED_MODULE_9__util__["a" /* noop */],
  onTitleMouseEnter: __WEBPACK_IMPORTED_MODULE_9__util__["a" /* noop */],
  onTitleMouseLeave: __WEBPACK_IMPORTED_MODULE_9__util__["a" /* noop */],
  onTitleClick: __WEBPACK_IMPORTED_MODULE_9__util__["a" /* noop */],
  manualRef: __WEBPACK_IMPORTED_MODULE_9__util__["a" /* noop */],
  mode: 'vertical',
  title: ''
};
var connected = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6_mini_store__["connect"])(function (_ref, _ref2) {
  var openKeys = _ref.openKeys,
      activeKey = _ref.activeKey,
      selectedKeys = _ref.selectedKeys;
  var eventKey = _ref2.eventKey,
      subMenuKey = _ref2.subMenuKey;
  return {
    isOpen: openKeys.indexOf(eventKey) > -1,
    active: activeKey[subMenuKey] === eventKey,
    selectedKeys: selectedKeys
  };
})(SubMenu);
connected.isSubMenu = true;
/* harmony default export */ __webpack_exports__["a"] = (connected);

/***/ }),
/* 470 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = getActiveKey;
/* unused harmony export saveRef */
/* unused harmony export SubPopupMenu */
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_mini_store__ = __webpack_require__(185);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_mini_store___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_mini_store__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__ = __webpack_require__(87);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rc_util_es_createChainedFunction__ = __webpack_require__(1164);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__util__ = __webpack_require__(111);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__DOMWrap__ = __webpack_require__(1141);
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function allDisabled(arr) {
  if (!arr.length) {
    return true;
  }

return arr.every(function (c) {
    return !!c.props.disabled;
  });
}

function updateActiveKey(store, menuId, activeKey) {
  var state = store.getState();
  store.setState({
    activeKey: _objectSpread({}, state.activeKey, _defineProperty({}, menuId, activeKey))
  });
}

function getEventKey(props) {
  // when eventKey not available ,it's menu and return menu id '0-menu-'
  return props.eventKey || '0-menu-';
}

function getActiveKey(props, originalActiveKey) {
  var activeKey = originalActiveKey;
  var children = props.children,
      eventKey = props.eventKey;

if (activeKey) {
    var found;
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5__util__["b" /* loopMenuItem */])(children, function (c, i) {
      if (c && c.props && !c.props.disabled && activeKey === __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5__util__["c" /* getKeyFromChildrenIndex */])(c, eventKey, i)) {
        found = true;
      }
    });

if (found) {
      return activeKey;
    }
  }

activeKey = null;

if (props.defaultActiveFirst) {
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5__util__["b" /* loopMenuItem */])(children, function (c, i) {
      if (!activeKey && c && !c.props.disabled) {
        activeKey = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5__util__["c" /* getKeyFromChildrenIndex */])(c, eventKey, i);
      }
    });
    return activeKey;
  }

return activeKey;
}
function saveRef(c) {
  if (c) {
    var index = this.instanceArray.indexOf(c);

if (index !== -1) {
      // update component if it's already inside instanceArray
      this.instanceArray[index] = c;
    } else {
      // add component if it's not in instanceArray yet;
      this.instanceArray.push(c);
    }
  }
}
var SubPopupMenu =
/*#__PURE__*/
function (_React$Component) {
  _inherits(SubPopupMenu, _React$Component);

function SubPopupMenu(props) {
    var _this;

_classCallCheck(this, SubPopupMenu);

_this = _possibleConstructorReturn(this, _getPrototypeOf(SubPopupMenu).call(this, props));
    /**
     * all keyboard events callbacks run from here at first
     *
     * note:
     *  This legacy code that `onKeyDown` is called by parent instead of dom self.
     *  which need return code to check if this event is handled
     */

_this.onKeyDown = function (e, callback) {
      var keyCode = e.keyCode;
      var handled;

_this.getFlatInstanceArray().forEach(function (obj) {
        if (obj && obj.props.active && obj.onKeyDown) {
          handled = obj.onKeyDown(e);
        }
      });

if (handled) {
        return 1;
      }

var activeItem = null;

if (keyCode === __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].UP || keyCode === __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].DOWN) {
        activeItem = _this.step(keyCode === __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].UP ? -1 : 1);
      }

if (activeItem) {
        e.preventDefault();
        updateActiveKey(_this.props.store, getEventKey(_this.props), activeItem.props.eventKey);

if (typeof callback === 'function') {
          callback(activeItem);
        }

return 1;
      }

return undefined;
    };

_this.onItemHover = function (e) {
      var key = e.key,
          hover = e.hover;
      updateActiveKey(_this.props.store, getEventKey(_this.props), hover ? key : null);
    };

_this.onDeselect = function (selectInfo) {
      _this.props.onDeselect(selectInfo);
    };

_this.onSelect = function (selectInfo) {
      _this.props.onSelect(selectInfo);
    };

_this.onClick = function (e) {
      _this.props.onClick(e);
    };

_this.onOpenChange = function (e) {
      _this.props.onOpenChange(e);
    };

_this.onDestroy = function (key) {
      /* istanbul ignore next */
      _this.props.onDestroy(key);
    };

_this.getFlatInstanceArray = function () {
      return _this.instanceArray;
    };

_this.getOpenTransitionName = function () {
      return _this.props.openTransitionName;
    };

_this.step = function (direction) {
      var children = _this.getFlatInstanceArray();

var activeKey = _this.props.store.getState().activeKey[getEventKey(_this.props)];

var len = children.length;

if (!len) {
        return null;
      }

if (direction < 0) {
        children = children.concat().reverse();
      } // find current activeIndex

var activeIndex = -1;
      children.every(function (c, ci) {
        if (c && c.props.eventKey === activeKey) {
          activeIndex = ci;
          return false;
        }

return true;
      });

if (!_this.props.defaultActiveFirst && activeIndex !== -1 && allDisabled(children.slice(activeIndex, len - 1))) {
        return undefined;
      }

var start = (activeIndex + 1) % len;
      var i = start;

do {
        var child = children[i];

if (!child || child.props.disabled) {
          i = (i + 1) % len;
        } else {
          return child;
        }
      } while (i !== start);

return null;
    };

_this.renderCommonMenuItem = function (child, i, extraProps) {
      var state = _this.props.store.getState();

var _assertThisInitialize = _assertThisInitialized(_this),
          props = _assertThisInitialize.props;

var key = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5__util__["c" /* getKeyFromChildrenIndex */])(child, props.eventKey, i);
      var childProps = child.props; // https://github.com/ant-design/ant-design/issues/11517#issuecomment-477403055

if (!childProps || typeof child.type === 'string') {
        return child;
      }

var isActive = key === state.activeKey;

var newChildProps = _objectSpread({
        mode: childProps.mode || props.mode,
        level: props.level,
        inlineIndent: props.inlineIndent,
        renderMenuItem: _this.renderMenuItem,
        rootPrefixCls: props.prefixCls,
        index: i,
        parentMenu: props.parentMenu,
        // customized ref function, need to be invoked manually in child's componentDidMount
        manualRef: childProps.disabled ? undefined : __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3_rc_util_es_createChainedFunction__["a" /* default */])(child.ref, saveRef.bind(_assertThisInitialized(_this))),
        eventKey: key,
        active: !childProps.disabled && isActive,
        multiple: props.multiple,
        onClick: function onClick(e) {
          (childProps.onClick || __WEBPACK_IMPORTED_MODULE_5__util__["a" /* noop */])(e);

_this.onClick(e);
        },
        onItemHover: _this.onItemHover,
        openTransitionName: _this.getOpenTransitionName(),
        openAnimation: props.openAnimation,
        subMenuOpenDelay: props.subMenuOpenDelay,
        subMenuCloseDelay: props.subMenuCloseDelay,
        forceSubMenuRender: props.forceSubMenuRender,
        onOpenChange: _this.onOpenChange,
        onDeselect: _this.onDeselect,
        onSelect: _this.onSelect,
        builtinPlacements: props.builtinPlacements,
        itemIcon: childProps.itemIcon || _this.props.itemIcon,
        expandIcon: childProps.expandIcon || _this.props.expandIcon
      }, extraProps); // ref: https://github.com/ant-design/ant-design/issues/13943

if (props.mode === 'inline' || __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5__util__["d" /* isMobileDevice */])()) {
        newChildProps.triggerSubMenuAction = 'click';
      }

return __WEBPACK_IMPORTED_MODULE_0_react___default.a.cloneElement(child, newChildProps);
    };

_this.renderMenuItem = function (c, i, subMenuKey) {
      /* istanbul ignore if */
      if (!c) {
        return null;
      }

var state = _this.props.store.getState();

var extraProps = {
        openKeys: state.openKeys,
        selectedKeys: state.selectedKeys,
        triggerSubMenuAction: _this.props.triggerSubMenuAction,
        subMenuKey: subMenuKey
      };
      return _this.renderCommonMenuItem(c, i, extraProps);
    };

props.store.setState({
      activeKey: _objectSpread({}, props.store.getState().activeKey, _defineProperty({}, props.eventKey, getActiveKey(props, props.activeKey)))
    });
    _this.instanceArray = [];
    return _this;
  }

_createClass(SubPopupMenu, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      // invoke customized ref to expose component to mixin
      if (this.props.manualRef) {
        this.props.manualRef(this);
      }
    }
  }, {
    key: "shouldComponentUpdate",
    value: function shouldComponentUpdate(nextProps) {
      return this.props.visible || nextProps.visible;
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate(prevProps) {
      var props = this.props;
      var originalActiveKey = 'activeKey' in props ? props.activeKey : props.store.getState().activeKey[getEventKey(props)];
      var activeKey = getActiveKey(props, originalActiveKey);

if (activeKey !== originalActiveKey) {
        updateActiveKey(props.store, getEventKey(props), activeKey);
      } else if ('activeKey' in prevProps) {
        // If prev activeKey is not same as current activeKey,
        // we should set it.
        var prevActiveKey = getActiveKey(prevProps, prevProps.activeKey);

if (activeKey !== prevActiveKey) {
          updateActiveKey(props.store, getEventKey(props), activeKey);
        }
      }
    }
  }, {
    key: "render",
    value: function render() {
      var _this2 = this;

var props = _extends({}, this.props);

this.instanceArray = [];
      var className = __WEBPACK_IMPORTED_MODULE_4_classnames___default()(props.prefixCls, props.className, "".concat(props.prefixCls, "-").concat(props.mode));
      var domProps = {
        className: className,
        // role could be 'select' and by default set to menu
        role: props.role || 'menu'
      };

if (props.id) {
        domProps.id = props.id;
      }

if (props.focusable) {
        domProps.tabIndex = 0;
        domProps.onKeyDown = this.onKeyDown;
      }

var prefixCls = props.prefixCls,
          eventKey = props.eventKey,
          visible = props.visible,
          level = props.level,
          mode = props.mode,
          overflowedIndicator = props.overflowedIndicator,
          theme = props.theme;
      __WEBPACK_IMPORTED_MODULE_5__util__["e" /* menuAllProps */].forEach(function (key) {
        return delete props[key];
      }); // Otherwise, the propagated click event will trigger another onClick

delete props.onClick;
      return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_6__DOMWrap__["a" /* default */], Object.assign({}, props, {
        prefixCls: prefixCls,
        mode: mode,
        tag: "ul",
        level: level,
        theme: theme,
        hiddenClassName: "".concat(prefixCls, "-hidden"),
        visible: visible,
        overflowedIndicator: overflowedIndicator
      }, domProps), __WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.map(props.children, function (c, i) {
        return _this2.renderMenuItem(c, i, eventKey || '0-menu-');
      }));
    }
  }]);

return SubPopupMenu;
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);
SubPopupMenu.defaultProps = {
  prefixCls: 'rc-menu',
  className: '',
  mode: 'vertical',
  level: 1,
  inlineIndent: 24,
  visible: true,
  focusable: true,
  style: {},
  manualRef: __WEBPACK_IMPORTED_MODULE_5__util__["a" /* noop */]
};
var connected = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1_mini_store__["connect"])()(SubPopupMenu);
/* harmony default export */ __webpack_exports__["b"] = (connected);

/***/ }),
/* 471 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Option; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react__);
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var Option =
/*#__PURE__*/
function (_Component) {
  _inherits(Option, _Component);

function Option() {
    _classCallCheck(this, Option);

return _possibleConstructorReturn(this, _getPrototypeOf(Option).apply(this, arguments));
  }

return Option;
}(__WEBPACK_IMPORTED_MODULE_1_react__["Component"]);

Option.propTypes = {
  value: __WEBPACK_IMPORTED_MODULE_0_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_0_prop_types__["string"], __WEBPACK_IMPORTED_MODULE_0_prop_types__["number"]])
};
Option.isSelectOption = true;

/***/ }),
/* 472 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_prop_types__);
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function propsValueType() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

var props = args[0],
      propName = args[1],
      componentName = args[2],
      rest = args.slice(3);
  var basicType = __WEBPACK_IMPORTED_MODULE_0_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_0_prop_types__["string"], __WEBPACK_IMPORTED_MODULE_0_prop_types__["number"]]);
  var labelInValueShape = __WEBPACK_IMPORTED_MODULE_0_prop_types__["shape"]({
    key: basicType.isRequired,
    label: __WEBPACK_IMPORTED_MODULE_0_prop_types__["node"]
  });

if (props.labelInValue) {
    var validate = __WEBPACK_IMPORTED_MODULE_0_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_0_prop_types__["arrayOf"](labelInValueShape), labelInValueShape]);
    var error = validate.apply(void 0, [props, propName, componentName].concat(_toConsumableArray(rest)));

if (error) {
      return new Error("Invalid prop `".concat(propName, "` supplied to `").concat(componentName, "`, ") + "when you set `labelInValue` to `true`, `".concat(propName, "` should in ") + "shape of `{ key: string | number, label?: ReactNode }`.");
    }
  } else if ((props.mode === 'multiple' || props.mode === 'tags' || props.multiple || props.tags) && props[propName] === '') {
    return new Error("Invalid prop `".concat(propName, "` of type `string` supplied to `").concat(componentName, "`, ") + "expected `array` when `multiple` or `tags` is `true`.");
  } else {
    var _validate = __WEBPACK_IMPORTED_MODULE_0_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_0_prop_types__["arrayOf"](basicType), basicType]);

return _validate.apply(void 0, [props, propName, componentName].concat(_toConsumableArray(rest)));
  }

return null;
}

var SelectPropTypes = {
  id: __WEBPACK_IMPORTED_MODULE_0_prop_types__["string"],
  defaultActiveFirstOption: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  multiple: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  filterOption: __WEBPACK_IMPORTED_MODULE_0_prop_types__["any"],
  children: __WEBPACK_IMPORTED_MODULE_0_prop_types__["any"],
  showSearch: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  disabled: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  allowClear: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  showArrow: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  tags: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  prefixCls: __WEBPACK_IMPORTED_MODULE_0_prop_types__["string"],
  className: __WEBPACK_IMPORTED_MODULE_0_prop_types__["string"],
  transitionName: __WEBPACK_IMPORTED_MODULE_0_prop_types__["string"],
  optionLabelProp: __WEBPACK_IMPORTED_MODULE_0_prop_types__["string"],
  optionFilterProp: __WEBPACK_IMPORTED_MODULE_0_prop_types__["string"],
  animation: __WEBPACK_IMPORTED_MODULE_0_prop_types__["string"],
  choiceTransitionName: __WEBPACK_IMPORTED_MODULE_0_prop_types__["string"],
  open: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  defaultOpen: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  onChange: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  onBlur: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  onFocus: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  onSelect: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  onSearch: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  onPopupScroll: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  onMouseEnter: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  onMouseLeave: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  onInputKeyDown: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  placeholder: __WEBPACK_IMPORTED_MODULE_0_prop_types__["any"],
  onDeselect: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  labelInValue: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  loading: __WEBPACK_IMPORTED_MODULE_0_prop_types__["bool"],
  value: propsValueType,
  defaultValue: propsValueType,
  dropdownStyle: __WEBPACK_IMPORTED_MODULE_0_prop_types__["object"],
  maxTagTextLength: __WEBPACK_IMPORTED_MODULE_0_prop_types__["number"],
  maxTagCount: __WEBPACK_IMPORTED_MODULE_0_prop_types__["number"],
  maxTagPlaceholder: __WEBPACK_IMPORTED_MODULE_0_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_0_prop_types__["node"], __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"]]),
  tokenSeparators: __WEBPACK_IMPORTED_MODULE_0_prop_types__["arrayOf"](__WEBPACK_IMPORTED_MODULE_0_prop_types__["string"]),
  getInputElement: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"],
  showAction: __WEBPACK_IMPORTED_MODULE_0_prop_types__["arrayOf"](__WEBPACK_IMPORTED_MODULE_0_prop_types__["string"]),
  clearIcon: __WEBPACK_IMPORTED_MODULE_0_prop_types__["node"],
  inputIcon: __WEBPACK_IMPORTED_MODULE_0_prop_types__["node"],
  removeIcon: __WEBPACK_IMPORTED_MODULE_0_prop_types__["node"],
  menuItemSelectedIcon: __WEBPACK_IMPORTED_MODULE_0_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_0_prop_types__["func"], __WEBPACK_IMPORTED_MODULE_0_prop_types__["node"]]),
  dropdownRender: __WEBPACK_IMPORTED_MODULE_0_prop_types__["func"]
};
/* harmony default export */ __webpack_exports__["a"] = (SelectPropTypes);

/***/ }),
/* 473 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__OptGroup__ = __webpack_require__(1150);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__Option__ = __webpack_require__(471);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__PropTypes__ = __webpack_require__(472);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__Select__ = __webpack_require__(1151);
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return __WEBPACK_IMPORTED_MODULE_1__Option__["a"]; });
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return __WEBPACK_IMPORTED_MODULE_0__OptGroup__["a"]; });
/* unused harmony reexport SelectPropTypes */

__WEBPACK_IMPORTED_MODULE_3__Select__["a" /* default */].Option = __WEBPACK_IMPORTED_MODULE_1__Option__["a" /* default */];
__WEBPACK_IMPORTED_MODULE_3__Select__["a" /* default */].OptGroup = __WEBPACK_IMPORTED_MODULE_0__OptGroup__["a" /* default */];

/* harmony default export */ __webpack_exports__["a"] = (__WEBPACK_IMPORTED_MODULE_3__Select__["a" /* default */]);

/***/ }),
/* 474 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties__ = __webpack_require__(54);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_rc_util_es_Dom_addEventListener__ = __webpack_require__(141);

var Handle = function (_React$Component) {
  __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default()(Handle, _React$Component);

function Handle() {
    var _ref;

var _temp, _this, _ret;

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default()(this, Handle);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

return _ret = (_temp = (_this = __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default()(this, (_ref = Handle.__proto__ || Object.getPrototypeOf(Handle)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
      clickFocused: false
    }, _this.setHandleRef = function (node) {
      _this.handle = node;
    }, _this.handleMouseUp = function () {
      if (document.activeElement === _this.handle) {
        _this.setClickFocus(true);
      }
    }, _this.handleMouseDown = function () {
      // fix https://github.com/ant-design/ant-design/issues/15324
      _this.focus();
    }, _this.handleBlur = function () {
      _this.setClickFocus(false);
    }, _this.handleKeyDown = function () {
      _this.setClickFocus(false);
    }, _temp), __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default()(_this, _ret);
  }

__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default()(Handle, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      // mouseup won't trigger if mouse moved out of handle,
      // so we listen on document here.
      this.onMouseUpListener = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_10_rc_util_es_Dom_addEventListener__["a" /* default */])(document, 'mouseup', this.handleMouseUp);
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      if (this.onMouseUpListener) {
        this.onMouseUpListener.remove();
      }
    }
  }, {
    key: 'setClickFocus',
    value: function setClickFocus(focused) {
      this.setState({ clickFocused: focused });
    }
  }, {
    key: 'clickFocus',
    value: function clickFocus() {
      this.setClickFocus(true);
      this.focus();
    }
  }, {
    key: 'focus',
    value: function focus() {
      this.handle.focus();
    }
  }, {
    key: 'blur',
    value: function blur() {
      this.handle.blur();
    }
  }, {
    key: 'render',
    value: function render() {
      var _props = this.props,
          prefixCls = _props.prefixCls,
          vertical = _props.vertical,
          offset = _props.offset,
          style = _props.style,
          disabled = _props.disabled,
          min = _props.min,
          max = _props.max,
          value = _props.value,
          tabIndex = _props.tabIndex,
          restProps = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties___default()(_props, ['prefixCls', 'vertical', 'offset', 'style', 'disabled', 'min', 'max', 'value', 'tabIndex']);

var className = __WEBPACK_IMPORTED_MODULE_9_classnames___default()(this.props.className, __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()({}, prefixCls + '-handle-click-focused', this.state.clickFocused));

var postionStyle = vertical ? { bottom: offset + '%' } : { left: offset + '%' };
      var elStyle = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, style, postionStyle);

var _tabIndex = tabIndex || 0;
      if (disabled || tabIndex === null) {
        _tabIndex = null;
      }

return __WEBPACK_IMPORTED_MODULE_7_react___default.a.createElement('div', __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({
        ref: this.setHandleRef,
        tabIndex: _tabIndex
      }, restProps, {
        className: className,
        style: elStyle,
        onBlur: this.handleBlur,
        onKeyDown: this.handleKeyDown,
        onMouseDown: this.handleMouseDown

// aria attribute
        , role: 'slider',
        'aria-valuemin': min,
        'aria-valuemax': max,
        'aria-valuenow': value,
        'aria-disabled': !!disabled
      }));
    }
  }]);

return Handle;
}(__WEBPACK_IMPORTED_MODULE_7_react___default.a.Component);

/* harmony default export */ __webpack_exports__["a"] = (Handle);

Handle.propTypes = {
  prefixCls: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.string,
  className: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.string,
  vertical: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  offset: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number,
  style: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.object,
  disabled: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  min: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number,
  max: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number,
  value: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number,
  tabIndex: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number
};

/***/ }),
/* 475 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

/* eslint-disable react/prop-types */

var Track = function Track(props) {
  var className = props.className,
      included = props.included,
      vertical = props.vertical,
      offset = props.offset,
      length = props.length,
      style = props.style;

var positonStyle = vertical ? {
    bottom: offset + '%',
    height: length + '%'
  } : {
    left: offset + '%',
    width: length + '%'
  };

var elStyle = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, style, positonStyle);
  return included ? __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement('div', { className: className, style: elStyle }) : null;
};

/* harmony default export */ __webpack_exports__["a"] = (Track);

/***/ }),
/* 476 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = createSlider;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties__ = __webpack_require__(54);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_get__ = __webpack_require__(785);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_get___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_get__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_rc_util_es_Dom_addEventListener__ = __webpack_require__(141);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_11_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12_warning__ = __webpack_require__(117);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12_warning___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_12_warning__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__Steps__ = __webpack_require__(1156);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__Marks__ = __webpack_require__(1155);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_15__Handle__ = __webpack_require__(474);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_16__utils__ = __webpack_require__(300);

function noop() {}

function createSlider(Component) {
  var _class, _temp;

return _temp = _class = function (_Component) {
    __WEBPACK_IMPORTED_MODULE_7_babel_runtime_helpers_inherits___default()(ComponentEnhancer, _Component);

function ComponentEnhancer(props) {
      __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default()(this, ComponentEnhancer);

var _this = __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default()(this, (ComponentEnhancer.__proto__ || Object.getPrototypeOf(ComponentEnhancer)).call(this, props));

_this.onMouseDown = function (e) {
        if (e.button !== 0) {
          return;
        }

var isVertical = _this.props.vertical;
        var position = __WEBPACK_IMPORTED_MODULE_16__utils__["g" /* getMousePosition */](isVertical, e);
        if (!__WEBPACK_IMPORTED_MODULE_16__utils__["h" /* isEventFromHandle */](e, _this.handlesRefs)) {
          _this.dragOffset = 0;
        } else {
          var handlePosition = __WEBPACK_IMPORTED_MODULE_16__utils__["i" /* getHandleCenterPosition */](isVertical, e.target);
          _this.dragOffset = position - handlePosition;
          position = handlePosition;
        }
        _this.removeDocumentEvents();
        _this.onStart(position);
        _this.addDocumentMouseEvents();
      };

_this.onTouchStart = function (e) {
        if (__WEBPACK_IMPORTED_MODULE_16__utils__["j" /* isNotTouchEvent */](e)) return;

var isVertical = _this.props.vertical;
        var position = __WEBPACK_IMPORTED_MODULE_16__utils__["k" /* getTouchPosition */](isVertical, e);
        if (!__WEBPACK_IMPORTED_MODULE_16__utils__["h" /* isEventFromHandle */](e, _this.handlesRefs)) {
          _this.dragOffset = 0;
        } else {
          var handlePosition = __WEBPACK_IMPORTED_MODULE_16__utils__["i" /* getHandleCenterPosition */](isVertical, e.target);
          _this.dragOffset = position - handlePosition;
          position = handlePosition;
        }
        _this.onStart(position);
        _this.addDocumentTouchEvents();
        __WEBPACK_IMPORTED_MODULE_16__utils__["c" /* pauseEvent */](e);
      };

_this.onFocus = function (e) {
        var _this$props = _this.props,
            onFocus = _this$props.onFocus,
            vertical = _this$props.vertical;

if (__WEBPACK_IMPORTED_MODULE_16__utils__["h" /* isEventFromHandle */](e, _this.handlesRefs)) {
          var handlePosition = __WEBPACK_IMPORTED_MODULE_16__utils__["i" /* getHandleCenterPosition */](vertical, e.target);
          _this.dragOffset = 0;
          _this.onStart(handlePosition);
          __WEBPACK_IMPORTED_MODULE_16__utils__["c" /* pauseEvent */](e);
          if (onFocus) {
            onFocus(e);
          }
        }
      };

_this.onBlur = function (e) {
        var onBlur = _this.props.onBlur;

_this.onEnd();
        if (onBlur) {
          onBlur(e);
        }
      };

_this.onMouseUp = function () {
        if (_this.handlesRefs[_this.prevMovedHandleIndex]) {
          _this.handlesRefs[_this.prevMovedHandleIndex].clickFocus();
        }
      };

_this.onMouseMove = function (e) {
        if (!_this.sliderRef) {
          _this.onEnd();
          return;
        }
        var position = __WEBPACK_IMPORTED_MODULE_16__utils__["g" /* getMousePosition */](_this.props.vertical, e);
        _this.onMove(e, position - _this.dragOffset);
      };

_this.onTouchMove = function (e) {
        if (__WEBPACK_IMPORTED_MODULE_16__utils__["j" /* isNotTouchEvent */](e) || !_this.sliderRef) {
          _this.onEnd();
          return;
        }

var position = __WEBPACK_IMPORTED_MODULE_16__utils__["k" /* getTouchPosition */](_this.props.vertical, e);
        _this.onMove(e, position - _this.dragOffset);
      };

_this.onKeyDown = function (e) {
        if (_this.sliderRef && __WEBPACK_IMPORTED_MODULE_16__utils__["h" /* isEventFromHandle */](e, _this.handlesRefs)) {
          _this.onKeyboard(e);
        }
      };

_this.onClickMarkLabel = function (e, value) {
        e.stopPropagation();
        _this.onChange({ value: value });
        _this.setState({ value: value }, function () {
          return _this.onEnd(true);
        });
      };

_this.saveSlider = function (slider) {
        _this.sliderRef = slider;
      };

if (__WEBPACK_IMPORTED_MODULE_16__utils__["a" /* isDev */]()) {
        var step = props.step,
            max = props.max,
            min = props.min;

var isPointDiffEven = isFinite(max - min) ? (max - min) % step === 0 : true; // eslint-disable-line
        __WEBPACK_IMPORTED_MODULE_12_warning___default()(step && Math.floor(step) === step ? isPointDiffEven : true, 'Slider[max] - Slider[min] (%s) should be a multiple of Slider[step] (%s)', max - min, step);
      }
      _this.handlesRefs = {};
      return _this;
    }

__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default()(ComponentEnhancer, [{
      key: 'componentDidMount',
      value: function componentDidMount() {
        // Snapshot testing cannot handle refs, so be sure to null-check this.
        this.document = this.sliderRef && this.sliderRef.ownerDocument;

var _props = this.props,
            autoFocus = _props.autoFocus,
            disabled = _props.disabled;

if (autoFocus && !disabled) {
          this.focus();
        }
      }
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {
        if (__WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_get___default()(ComponentEnhancer.prototype.__proto__ || Object.getPrototypeOf(ComponentEnhancer.prototype), 'componentWillUnmount', this)) __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_get___default()(ComponentEnhancer.prototype.__proto__ || Object.getPrototypeOf(ComponentEnhancer.prototype), 'componentWillUnmount', this).call(this);
        this.removeDocumentEvents();
      }
    }, {
      key: 'getSliderStart',
      value: function getSliderStart() {
        var slider = this.sliderRef;
        var rect = slider.getBoundingClientRect();

return this.props.vertical ? rect.top : rect.left + window.pageXOffset;
      }
    }, {
      key: 'getSliderLength',
      value: function getSliderLength() {
        var slider = this.sliderRef;
        if (!slider) {
          return 0;
        }

this.onMouseMoveListener && this.onMouseMoveListener.remove();
        this.onMouseUpListener && this.onMouseUpListener.remove();
        /* eslint-enable no-unused-expressions */
      }
    }, {
      key: 'focus',
      value: function focus() {
        if (!this.props.disabled) {
          this.handlesRefs[0].focus();
        }
      }
    }, {
      key: 'blur',
      value: function blur() {
        var _this2 = this;

if (!this.props.disabled) {
          Object.keys(this.handlesRefs).forEach(function (key) {
            if (_this2.handlesRefs[key] && _this2.handlesRefs[key].blur) {
              _this2.handlesRefs[key].blur();
            }
          });
        }
      }
    }, {
      key: 'calcValue',
      value: function calcValue(offset) {
        var _props2 = this.props,
            vertical = _props2.vertical,
            min = _props2.min,
            max = _props2.max;

var _props4 = this.props,
            prefixCls = _props4.prefixCls,
            className = _props4.className,
            marks = _props4.marks,
            dots = _props4.dots,
            step = _props4.step,
            included = _props4.included,
            disabled = _props4.disabled,
            vertical = _props4.vertical,
            min = _props4.min,
            max = _props4.max,
            children = _props4.children,
            maximumTrackStyle = _props4.maximumTrackStyle,
            style = _props4.style,
            railStyle = _props4.railStyle,
            dotStyle = _props4.dotStyle,
            activeDotStyle = _props4.activeDotStyle;

var _get$call = __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_get___default()(ComponentEnhancer.prototype.__proto__ || Object.getPrototypeOf(ComponentEnhancer.prototype), 'render', this).call(this),
            tracks = _get$call.tracks,
            handles = _get$call.handles;

return ComponentEnhancer;
  }(Component), _class.displayName = 'ComponentEnhancer(' + Component.displayName + ')', _class.propTypes = __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, Component.propTypes, {
    min: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.number,
    max: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.number,
    step: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.number,
    marks: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object,
    included: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.bool,
    className: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.string,
    prefixCls: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.string,
    disabled: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.bool,
    children: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.any,
    onBeforeChange: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.func,
    onChange: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.func,
    onAfterChange: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.func,
    handle: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.func,
    dots: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.bool,
    vertical: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.bool,
    style: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object,
    minimumTrackStyle: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object, // just for compatibility, will be deperecate
    maximumTrackStyle: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object, // just for compatibility, will be deperecate
    handleStyle: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object, __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object)]),
    trackStyle: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object, __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object)]),
    railStyle: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object,
    dotStyle: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object,
    activeDotStyle: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.object,
    autoFocus: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.bool,
    onFocus: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.func,
    onBlur: __WEBPACK_IMPORTED_MODULE_9_prop_types___default.a.func
  }), _class.defaultProps = __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, Component.defaultProps, {
    prefixCls: 'rc-slider',
    className: '',
    min: 0,
    max: 100,
    step: 1,
    marks: {},
    handle: function handle(_ref) {
      var index = _ref.index,
          restProps = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties___default()(_ref, ['index']);

delete restProps.dragging;
      if (restProps.value === null) {
        return null;
      }

return __WEBPACK_IMPORTED_MODULE_8_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_15__Handle__["a" /* default */], __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, restProps, { key: index }));
    },

onBeforeChange: noop,
    onChange: noop,
    onAfterChange: noop,
    included: true,
    disabled: false,
    dots: false,
    vertical: false,
    trackStyle: [{}],
    handleStyle: [{}],
    railStyle: {},
    dotStyle: {},
    activeDotStyle: {}
  }), _temp;
}

/***/ }),
/* 477 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return placements; });
var autoAdjustOverflow = {
  adjustX: 1,
  adjustY: 1
};

var targetOffset = [0, 0];

var placements = {
  left: {
    points: ['cr', 'cl'],
    overflow: autoAdjustOverflow,
    offset: [-4, 0],
    targetOffset: targetOffset
  },
  right: {
    points: ['cl', 'cr'],
    overflow: autoAdjustOverflow,
    offset: [4, 0],
    targetOffset: targetOffset
  },
  top: {
    points: ['bc', 'tc'],
    overflow: autoAdjustOverflow,
    offset: [0, -4],
    targetOffset: targetOffset
  },
  bottom: {
    points: ['tc', 'bc'],
    overflow: autoAdjustOverflow,
    offset: [0, 4],
    targetOffset: targetOffset
  },
  topLeft: {
    points: ['bl', 'tl'],
    overflow: autoAdjustOverflow,
    offset: [0, -4],
    targetOffset: targetOffset
  },
  leftTop: {
    points: ['tr', 'tl'],
    overflow: autoAdjustOverflow,
    offset: [-4, 0],
    targetOffset: targetOffset
  },
  topRight: {
    points: ['br', 'tr'],
    overflow: autoAdjustOverflow,
    offset: [0, -4],
    targetOffset: targetOffset
  },
  rightTop: {
    points: ['tl', 'tr'],
    overflow: autoAdjustOverflow,
    offset: [4, 0],
    targetOffset: targetOffset
  },
  bottomRight: {
    points: ['tr', 'br'],
    overflow: autoAdjustOverflow,
    offset: [0, 4],
    targetOffset: targetOffset
  },
  rightBottom: {
    points: ['bl', 'br'],
    overflow: autoAdjustOverflow,
    offset: [4, 0],
    targetOffset: targetOffset
  },
  bottomLeft: {
    points: ['tl', 'bl'],
    overflow: autoAdjustOverflow,
    offset: [0, 4],
    targetOffset: targetOffset
  },
  leftBottom: {
    points: ['br', 'bl'],
    overflow: autoAdjustOverflow,
    offset: [-4, 0],
    targetOffset: targetOffset
  }
};

/* unused harmony default export */ var _unused_webpack_default_export = (placements);

/***/ }),
/* 478 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var LazyRenderBox = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(LazyRenderBox, _Component);

function LazyRenderBox() {
    __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, LazyRenderBox);

return __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, _Component.apply(this, arguments));
  }

LazyRenderBox.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
    return nextProps.hiddenClassName || nextProps.visible;
  };

LazyRenderBox.prototype.render = function render() {
    var _props = this.props,
        hiddenClassName = _props.hiddenClassName,
        visible = _props.visible,
        props = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties___default()(_props, ['hiddenClassName', 'visible']);

if (hiddenClassName || __WEBPACK_IMPORTED_MODULE_4_react___default.a.Children.count(props.children) > 1) {
      if (!visible && hiddenClassName) {
        props.className += ' ' + hiddenClassName;
      }
      return __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement('div', props);
    }

return __WEBPACK_IMPORTED_MODULE_4_react___default.a.Children.only(props.children);
  };

return LazyRenderBox;
}(__WEBPACK_IMPORTED_MODULE_4_react__["Component"]);

LazyRenderBox.propTypes = {
  children: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.any,
  className: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  visible: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  hiddenClassName: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string
};

/* harmony default export */ __webpack_exports__["a"] = (LazyRenderBox);

/***/ }),
/* 479 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = getAlignFromPlacement;
/* harmony export (immutable) */ __webpack_exports__["b"] = getAlignPopupClassName;
/* harmony export (immutable) */ __webpack_exports__["c"] = saveRef;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);

function isPointsEq(a1, a2, isAlignPoint) {
  if (isAlignPoint) {
    return a1[0] === a2[0];
  }
  return a1[0] === a2[0] && a1[1] === a2[1];
}

function getAlignFromPlacement(builtinPlacements, placementStr, align) {
  var baseAlign = builtinPlacements[placementStr] || {};
  return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, baseAlign, align);
}

function saveRef(name, component) {
  this[name] = component;
}

/***/ }),
/* 480 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = toArray;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_is__ = __webpack_require__(306);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_is___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_is__);

function toArray(children) {
  var ret = [];
  __WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.forEach(children, function (child) {
    if (child === undefined || child === null) {
      return;
    }

if (Array.isArray(child)) {
      ret = ret.concat(toArray(child));
    } else if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1_react_is__["isFragment"])(child) && child.props) {
      ret = ret.concat(toArray(child.props.children));
    } else {
      ret.push(child);
    }
  });
  return ret;
}

/***/ }),
/* 481 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return ContainerRender; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_prop_types__);
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

var ContainerRender = /*#__PURE__*/function (_React$Component) {
  _inherits(ContainerRender, _React$Component);

var _super = _createSuper(ContainerRender);

function ContainerRender() {
    var _this;

_classCallCheck(this, ContainerRender);

for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

_this = _super.call.apply(_super, [this].concat(args));

_this.removeContainer = function () {
      if (_this.container) {
        __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.unmountComponentAtNode(_this.container);

_this.container.parentNode.removeChild(_this.container);

_this.container = null;
      }
    };

_this.renderComponent = function (props, ready) {
      var _this$props = _this.props,
          visible = _this$props.visible,
          getComponent = _this$props.getComponent,
          forceRender = _this$props.forceRender,
          getContainer = _this$props.getContainer,
          parent = _this$props.parent;

if (visible || parent._component || forceRender) {
        if (!_this.container) {
          _this.container = getContainer();
        }

__WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.unstable_renderSubtreeIntoContainer(parent, getComponent(props), _this.container, function callback() {
          if (ready) {
            ready.call(this);
          }
        });
      }
    };

return _this;
  }

_createClass(ContainerRender, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      if (this.props.autoMount) {
        this.renderComponent();
      }
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate() {
      if (this.props.autoMount) {
        this.renderComponent();
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      if (this.props.autoDestroy) {
        this.removeContainer();
      }
    }
  }, {
    key: "render",
    value: function render() {
      return this.props.children({
        renderComponent: this.renderComponent,
        removeContainer: this.removeContainer
      });
    }
  }]);

return ContainerRender;
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);

ContainerRender.propTypes = {
  autoMount: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.bool,
  autoDestroy: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.bool,
  visible: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.bool,
  forceRender: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.bool,
  parent: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.any,
  getComponent: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.func.isRequired,
  getContainer: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.func.isRequired,
  children: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.func.isRequired
};
ContainerRender.defaultProps = {
  autoMount: true,
  autoDestroy: true,
  forceRender: false
};

/***/ }),
/* 482 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Portal; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_prop_types__);
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

var Portal = /*#__PURE__*/function (_React$Component) {
  _inherits(Portal, _React$Component);

var _super = _createSuper(Portal);

function Portal() {
    _classCallCheck(this, Portal);

return _super.apply(this, arguments);
  }

_createClass(Portal, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.createContainer();
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate(prevProps) {
      var didUpdate = this.props.didUpdate;

if (didUpdate) {
        didUpdate(prevProps);
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.removeContainer();
    }
  }, {
    key: "createContainer",
    value: function createContainer() {
      this._container = this.props.getContainer();
      this.forceUpdate();
    }
  }, {
    key: "removeContainer",
    value: function removeContainer() {
      if (this._container) {
        this._container.parentNode.removeChild(this._container);
      }
    }
  }, {
    key: "render",
    value: function render() {
      if (this._container) {
        return __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.createPortal(this.props.children, this._container);
      }

return null;
    }
  }]);

return Portal;
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);

Portal.propTypes = {
  getContainer: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.func.isRequired,
  children: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.node.isRequired,
  didUpdate: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.func
};

/***/ }),
/* 483 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Checkboard = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _checkboard = __webpack_require__(1210);

var checkboard = _interopRequireWildcard(_checkboard);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Checkboard = exports.Checkboard = function Checkboard(_ref) {
  var white = _ref.white,
      grey = _ref.grey,
      size = _ref.size,
      renderers = _ref.renderers,
      borderRadius = _ref.borderRadius,
      boxShadow = _ref.boxShadow;

var styles = (0, _reactcss2.default)({
    'default': {
      grid: {
        borderRadius: borderRadius,
        boxShadow: boxShadow,
        absolute: '0px 0px 0px 0px',
        background: 'url(' + checkboard.get(white, grey, size, renderers.canvas) + ') center left'
      }
    }
  });

return _react2.default.createElement('div', { style: styles.grid });
};

Checkboard.defaultProps = {
  size: 8,
  white: 'transparent',
  grey: 'rgba(0,0,0,.08)',
  renderers: {}
};

exports.default = Checkboard;

/***/ }),
/* 484 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ColorWrap = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _debounce = __webpack_require__(291);

var _debounce2 = _interopRequireDefault(_debounce);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var ColorWrap = exports.ColorWrap = function ColorWrap(Picker) {
  var ColorPicker = function (_ref) {
    _inherits(ColorPicker, _ref);

function ColorPicker(props) {
      _classCallCheck(this, ColorPicker);

var _this = _possibleConstructorReturn(this, (ColorPicker.__proto__ || Object.getPrototypeOf(ColorPicker)).call(this));

_this.handleChange = function (data, event) {
        var isValidColor = _color2.default.simpleCheckForValidColor(data);
        if (isValidColor) {
          var colors = _color2.default.toState(data, data.h || _this.state.oldHue);
          _this.setState(colors);
          _this.props.onChangeComplete && _this.debounce(_this.props.onChangeComplete, colors, event);
          _this.props.onChange && _this.props.onChange(colors, event);
        }
      };

_this.handleSwatchHover = function (data, event) {
        var isValidColor = _color2.default.simpleCheckForValidColor(data);
        if (isValidColor) {
          var colors = _color2.default.toState(data, data.h || _this.state.oldHue);
          _this.setState(colors);
          _this.props.onSwatchHover && _this.props.onSwatchHover(colors, event);
        }
      };

_this.state = _extends({}, _color2.default.toState(props.color, 0));

_this.debounce = (0, _debounce2.default)(function (fn, data, event) {
        fn(data, event);
      }, 100);
      return _this;
    }

_createClass(ColorPicker, [{
      key: 'componentWillReceiveProps',
      value: function componentWillReceiveProps(nextProps) {
        this.setState(_extends({}, _color2.default.toState(nextProps.color, this.state.oldHue)));
      }
    }, {
      key: 'render',
      value: function render() {
        var optionalEvents = {};
        if (this.props.onSwatchHover) {
          optionalEvents.onSwatchHover = this.handleSwatchHover;
        }

return _react2.default.createElement(Picker, _extends({}, this.props, this.state, {
          onChange: this.handleChange
        }, optionalEvents));
      }
    }]);

return ColorPicker;
  }(_react.PureComponent || _react.Component);

ColorPicker.propTypes = _extends({}, Picker.propTypes);

ColorPicker.defaultProps = _extends({}, Picker.defaultProps, {
    color: {
      h: 250,
      s: 0.50,
      l: 0.20,
      a: 1
    }
  });

return ColorPicker;
};

exports.default = ColorWrap;

/***/ }),
/* 485 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _lodashMemoize = __webpack_require__(455);

var _lodashMemoize2 = _interopRequireDefault(_lodashMemoize);

var isFirefox = _lodashMemoize2['default'](function () {
  return (/firefox/i.test(navigator.userAgent)
  );
});

exports.isFirefox = isFirefox;
var isSafari = _lodashMemoize2['default'](function () {
  return Boolean(window.safari);
});
exports.isSafari = isSafari;

/***/ }),
/* 486 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = areOptionsEqual;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _utilsShallowEqual = __webpack_require__(305);

var _utilsShallowEqual2 = _interopRequireDefault(_utilsShallowEqual);

function areOptionsEqual(nextOptions, currentOptions) {
  if (currentOptions === nextOptions) {
    return true;
  }

return currentOptions !== null && nextOptions !== null && _utilsShallowEqual2['default'](currentOptions, nextOptions);
}

module.exports = exports['default'];

/***/ }),
/* 487 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

exports['default'] = decorateHandler;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _disposables = __webpack_require__(849);

var _utilsShallowEqual = __webpack_require__(305);

var _utilsShallowEqual2 = _interopRequireDefault(_utilsShallowEqual);

var _utilsShallowEqualScalar = __webpack_require__(489);

var _utilsShallowEqualScalar2 = _interopRequireDefault(_utilsShallowEqualScalar);

var _lodashIsPlainObject = __webpack_require__(48);

var _lodashIsPlainObject2 = _interopRequireDefault(_lodashIsPlainObject);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

function decorateHandler(_ref) {
  var DecoratedComponent = _ref.DecoratedComponent;
  var createHandler = _ref.createHandler;
  var createMonitor = _ref.createMonitor;
  var createConnector = _ref.createConnector;
  var registerHandler = _ref.registerHandler;
  var containerDisplayName = _ref.containerDisplayName;
  var getType = _ref.getType;
  var collect = _ref.collect;
  var options = _ref.options;
  var _options$arePropsEqual = options.arePropsEqual;
  var arePropsEqual = _options$arePropsEqual === undefined ? _utilsShallowEqualScalar2['default'] : _options$arePropsEqual;

var displayName = DecoratedComponent.displayName || DecoratedComponent.name || 'Component';

return (function (_Component) {
    _inherits(DragDropContainer, _Component);

DragDropContainer.prototype.getHandlerId = function getHandlerId() {
      return this.handlerId;
    };

DragDropContainer.prototype.getDecoratedComponentInstance = function getDecoratedComponentInstance() {
      return this.decoratedComponentInstance;
    };

DragDropContainer.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
      return !arePropsEqual(nextProps, this.props) || !_utilsShallowEqual2['default'](nextState, this.state);
    };

_createClass(DragDropContainer, null, [{
      key: 'DecoratedComponent',
      value: DecoratedComponent,
      enumerable: true
    }, {
      key: 'displayName',
      value: containerDisplayName + '(' + displayName + ')',
      enumerable: true
    }, {
      key: 'contextTypes',
      value: {
        dragDropManager: _react.PropTypes.object.isRequired
      },
      enumerable: true
    }]);

function DragDropContainer(props, context) {
      _classCallCheck(this, DragDropContainer);

_Component.call(this, props, context);
      this.handleChange = this.handleChange.bind(this);
      this.handleChildRef = this.handleChildRef.bind(this);

_invariant2['default'](typeof this.context.dragDropManager === 'object', 'Could not find the drag and drop manager in the context of %s. ' + 'Make sure to wrap the top-level component of your app with DragDropContext. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-troubleshooting.html#could-not-find-the-drag-and-drop-manager-in-the-context', displayName, displayName);

this.manager = this.context.dragDropManager;
      this.handlerMonitor = createMonitor(this.manager);
      this.handlerConnector = createConnector(this.manager.getBackend());
      this.handler = createHandler(this.handlerMonitor);

this.disposable = new _disposables.SerialDisposable();
      this.receiveProps(props);
      this.state = this.getCurrentState();
      this.dispose();
    }

DragDropContainer.prototype.componentDidMount = function componentDidMount() {
      this.isCurrentlyMounted = true;
      this.disposable = new _disposables.SerialDisposable();
      this.currentType = null;
      this.receiveProps(this.props);
      this.handleChange();
    };

DragDropContainer.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
      if (!arePropsEqual(nextProps, this.props)) {
        this.receiveProps(nextProps);
        this.handleChange();
      }
    };

DragDropContainer.prototype.componentWillUnmount = function componentWillUnmount() {
      this.dispose();
      this.isCurrentlyMounted = false;
    };

DragDropContainer.prototype.receiveProps = function receiveProps(props) {
      this.handler.receiveProps(props);
      this.receiveType(getType(props));
    };

DragDropContainer.prototype.receiveType = function receiveType(type) {
      if (type === this.currentType) {
        return;
      }

this.currentType = type;

var _registerHandler = registerHandler(type, this.handler, this.manager);

var handlerId = _registerHandler.handlerId;
      var unregister = _registerHandler.unregister;

this.handlerId = handlerId;
      this.handlerMonitor.receiveHandlerId(handlerId);
      this.handlerConnector.receiveHandlerId(handlerId);

var globalMonitor = this.manager.getMonitor();
      var unsubscribe = globalMonitor.subscribeToStateChange(this.handleChange, { handlerIds: [handlerId] });

this.disposable.setDisposable(new _disposables.CompositeDisposable(new _disposables.Disposable(unsubscribe), new _disposables.Disposable(unregister)));
    };

DragDropContainer.prototype.handleChange = function handleChange() {
      if (!this.isCurrentlyMounted) {
        return;
      }

var nextState = this.getCurrentState();
      if (!_utilsShallowEqual2['default'](nextState, this.state)) {
        this.setState(nextState);
      }
    };

DragDropContainer.prototype.dispose = function dispose() {
      this.disposable.dispose();
      this.handlerConnector.receiveHandlerId(null);
    };

DragDropContainer.prototype.handleChildRef = function handleChildRef(component) {
      this.decoratedComponentInstance = component;
      this.handler.receiveComponent(component);
    };

DragDropContainer.prototype.getCurrentState = function getCurrentState() {
      var nextState = collect(this.handlerConnector.hooks, this.handlerMonitor);

if (process.env.NODE_ENV !== 'production') {
        _invariant2['default'](_lodashIsPlainObject2['default'](nextState), 'Expected `collect` specified as the second argument to ' + '%s for %s to return a plain object of props to inject. ' + 'Instead, received %s.', containerDisplayName, displayName, nextState);
      }

return nextState;
    };

DragDropContainer.prototype.render = function render() {
      return _react2['default'].createElement(DecoratedComponent, _extends({}, this.props, this.state, {
        ref: this.handleChildRef }));
    };

return DragDropContainer;
  })(_react.Component);
}

module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 488 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = isValidType;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _lodashIsArray = __webpack_require__(27);

var _lodashIsArray2 = _interopRequireDefault(_lodashIsArray);

function isValidType(type, allowArray) {
       return typeof type === 'string' || typeof type === 'symbol' || allowArray && _lodashIsArray2['default'](type) && type.every(function (t) {
              return isValidType(t, false);
       });
}

module.exports = exports['default'];

/***/ }),
/* 489 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = shallowEqualScalar;

function shallowEqualScalar(objA, objB) {
  if (objA === objB) {
    return true;
  }

if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
    return false;
  }

var keysA = Object.keys(objA);
  var keysB = Object.keys(objB);

if (keysA.length !== keysB.length) {
    return false;
  }

// Test for A's keys different from B.
  var hasOwn = Object.prototype.hasOwnProperty;
  for (var i = 0; i < keysA.length; i++) {
    if (!hasOwn.call(objB, keysA[i])) {
      return false;
    }

var valA = objA[keysA[i]];
    var valB = objB[keysA[i]];

if (valA !== valB || typeof valA === 'object' || typeof valB === 'object') {
      return false;
    }
  }

return true;
}

module.exports = exports['default'];

/***/ }),
/* 490 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = wrapConnectorHooks;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _utilsCloneWithRef = __webpack_require__(1235);

var _utilsCloneWithRef2 = _interopRequireDefault(_utilsCloneWithRef);

var _react = __webpack_require__(0);

function throwIfCompositeComponentElement(element) {
  // Custom components can no longer be wrapped directly in React DnD 2.0
  // so that we don't need to depend on findDOMNode() from react-dom.
  if (typeof element.type === 'string') {
    return;
  }

var displayName = element.type.displayName || element.type.name || 'the component';

throw new Error('Only native element nodes can now be passed to React DnD connectors. ' + ('You can either wrap ' + displayName + ' into a <div>, or turn it into a ') + 'drag source or a drop target itself.');
}

function wrapHookToRecognizeElement(hook) {
  return function () {
    var elementOrNode = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0];
    var options = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];

// When passed a node, call the hook straight away.
    if (!_react.isValidElement(elementOrNode)) {
      var node = elementOrNode;
      hook(node, options);
      return;
    }

// If passed a ReactElement, clone it and attach this function as a ref.
    // This helps us achieve a neat API where user doesn't even know that refs
    // are being used under the hood.
    var element = elementOrNode;
    throwIfCompositeComponentElement(element);

// When no options are passed, use the hook directly
    var ref = options ? function (node) {
      return hook(node, options);
    } : hook;

return _utilsCloneWithRef2['default'](element, ref);
  };
}

function wrapConnectorHooks(hooks) {
  var wrappedHooks = {};

Object.keys(hooks).forEach(function (key) {
    var hook = hooks[key];
    var wrappedHook = wrapHookToRecognizeElement(hook);
    wrappedHooks[key] = function () {
      return wrappedHook;
    };
  });

return wrappedHooks;
}

module.exports = exports['default'];

/***/ }),
/* 491 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.convertToInt = convertToInt;
exports.convertAllToInt = convertAllToInt;
exports.filterNewItems = filterNewItems;
exports.applyStylesToDOMNode = applyStylesToDOMNode;
exports.whichTransitionEvent = whichTransitionEvent;
/**
 * React Flip Move
 * (c) 2016-present Joshua Comeau
 */

function convertToInt(val, propName) {
  var int = typeof val === 'string' ? parseInt(val) : val;

if (isNaN(int)) {
    console.error('Invalid prop \'' + propName + '\' supplied to FlipMove. Expected a number, or a string that can easily be resolved to a number (eg. "100"). Instead, received \'' + val + '\'.');
  }

return int;
}

function convertAllToInt() {
  for (var _len = arguments.length, values = Array(_len), _key = 0; _key < _len; _key++) {
    values[_key] = arguments[_key];
  }

return values.map(convertToInt);
}

function filterNewItems(group1, group2) {
  var idProp = arguments.length <= 2 || arguments[2] === undefined ? 'key' : arguments[2];

// We want to find all items in group2 that are NOT in group1.
  return group2.filter(function (g2Item) {
    return !group1.find(function (g1Item) {
      return g1Item[idProp] === g2Item[idProp];
    });
  });
}

function applyStylesToDOMNode(domNode, styles) {
  // Can't just do an object merge because domNode.styles is no regular object.
  // Need to do it this way for the engine to fire its `set` listeners.
  Object.keys(styles).forEach(function (key) {
    domNode.style[key] = styles[key];
  });
}

// Modified from Modernizr
function whichTransitionEvent() {
  var transitions = {
    'transition': 'transitionend',
    'OTransition': 'oTransitionEnd',
    'MozTransition': 'transitionend',
    'WebkitTransition': 'webkitTransitionEnd'
  };

// If we're running in a browserless environment (eg. SSR), it doesn't apply.
  // Return a string so that it maintains the type that is expected.
  if (typeof document === 'undefined') return '';

var el = document.createElement('fakeelement');

for (var t in transitions) {
    if (el.style[t] !== undefined) return transitions[t];
  }
}

/***/ }),
/* 492 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * React Flip Move
 * (c) 2016-present Joshua Comeau
 */
module.exports = __webpack_require__(1237);

/***/ }),
/* 493 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _PropTypes = __webpack_require__(308);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _React$PropTypes = _react2.default.PropTypes;
var bool = _React$PropTypes.bool;
var object = _React$PropTypes.object;
var string = _React$PropTypes.string;
var func = _React$PropTypes.func;
var oneOfType = _React$PropTypes.oneOfType;

function isLeftClickEvent(event) {
  return event.button === 0;
}

function isModifiedEvent(event) {
  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
}

// TODO: De-duplicate against hasAnyProperties in createTransitionManager.
function isEmptyObject(object) {
  for (var p in object) {
    if (Object.prototype.hasOwnProperty.call(object, p)) return false;
  }return true;
}

function createLocationDescriptor(to, _ref) {
  var query = _ref.query;
  var hash = _ref.hash;
  var state = _ref.state;

if (query || hash || state) {
    return { pathname: to, query: query, hash: hash, state: state };
  }

return to;
}

/**
 * A <Link> is used to create an <a> element that links to a route.
 * When that route is active, the link gets the value of its
 * activeClassName prop.
 *
 * For example, assuming you have the following route:
 *
 *   <Route path="/posts/:postID" component={Post} />
 *
 * You could use the following component to link to that route:
 *
 *   <Link to={`/posts/${post.id}`} />
 *
 * Links may pass along location state and/or query string parameters
 * in the state/query props, respectively.
 *
 *   <Link ... query={{ show: true }} state={{ the: 'state' }} />
 */
var Link = _react2.default.createClass({
  displayName: 'Link',

contextTypes: {
    router: _PropTypes.routerShape
  },

propTypes: {
    to: oneOfType([string, object]),
    query: object,
    hash: string,
    state: object,
    activeStyle: object,
    activeClassName: string,
    onlyActiveOnIndex: bool.isRequired,
    onClick: func,
    target: string
  },

getDefaultProps: function getDefaultProps() {
    return {
      onlyActiveOnIndex: false,
      style: {}
    };
  },
  handleClick: function handleClick(event) {
    if (this.props.onClick) this.props.onClick(event);

if (event.defaultPrevented) return;

!this.context.router ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, '<Link>s rendered outside of a router context cannot navigate.') : (0, _invariant2.default)(false) : void 0;

if (isModifiedEvent(event) || !isLeftClickEvent(event)) return;

// If target prop is set (e.g. to "_blank"), let browser handle link.
    /* istanbul ignore if: untestable with Karma */
    if (this.props.target) return;

event.preventDefault();

var _props = this.props;
    var to = _props.to;
    var query = _props.query;
    var hash = _props.hash;
    var state = _props.state;

var location = createLocationDescriptor(to, { query: query, hash: hash, state: state });

this.context.router.push(location);
  },
  render: function render() {
    var _props2 = this.props;
    var to = _props2.to;
    var query = _props2.query;
    var hash = _props2.hash;
    var state = _props2.state;
    var activeClassName = _props2.activeClassName;
    var activeStyle = _props2.activeStyle;
    var onlyActiveOnIndex = _props2.onlyActiveOnIndex;

var props = _objectWithoutProperties(_props2, ['to', 'query', 'hash', 'state', 'activeClassName', 'activeStyle', 'onlyActiveOnIndex']);

process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(!(query || hash || state), 'the `query`, `hash`, and `state` props on `<Link>` are deprecated, use `<Link to={{ pathname, query, hash, state }}/>. http://tiny.cc/router-isActivedeprecated') : void 0;

// Ignore if rendered outside the context of router, simplifies unit testing.
    var router = this.context.router;

if (router) {
      // If user does not specify a `to` prop, return an empty anchor tag.
      if (to == null) {
        return _react2.default.createElement('a', props);
      }

var location = createLocationDescriptor(to, { query: query, hash: hash, state: state });
      props.href = router.createHref(location);

if (activeClassName || activeStyle != null && !isEmptyObject(activeStyle)) {
        if (router.isActive(location, onlyActiveOnIndex)) {
          if (activeClassName) {
            if (props.className) {
              props.className += ' ' + activeClassName;
            } else {
              props.className = activeClassName;
            }
          }

if (activeStyle) props.style = _extends({}, props.style, activeStyle);
        }
      }
    }

return _react2.default.createElement('a', _extends({}, props, { onClick: this.handleClick }));
  }
});

exports.default = Link;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 494 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _RouteUtils = __webpack_require__(75);

var _PatternUtils = __webpack_require__(112);

var _InternalPropTypes = __webpack_require__(88);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _React$PropTypes = _react2.default.PropTypes;
var string = _React$PropTypes.string;
var object = _React$PropTypes.object;

/**
 * A <Redirect> is used to declare another URL path a client should
 * be sent to when they request a given URL.
 *
 * Redirects are placed alongside routes in the route configuration
 * and are traversed in the same manner.
 */

var Redirect = _react2.default.createClass({
  displayName: 'Redirect',

statics: {
    createRouteFromReactElement: function createRouteFromReactElement(element) {
      var route = (0, _RouteUtils.createRouteFromReactElement)(element);

if (route.from) route.path = route.from;

route.onEnter = function (nextState, replace) {
        var location = nextState.location;
        var params = nextState.params;

replace({
          pathname: pathname,
          query: route.query || location.query,
          state: route.state || location.state
        });
      };

return route;
    },
    getRoutePattern: function getRoutePattern(routes, routeIndex) {
      var parentPattern = '';

for (var i = routeIndex; i >= 0; i--) {
        var route = routes[i];
        var pattern = route.path || '';

parentPattern = pattern.replace(/\/*$/, '/') + parentPattern;

if (pattern.indexOf('/') === 0) break;
      }

return '/' + parentPattern;
    }
  },

propTypes: {
    path: string,
    from: string, // Alias for path
    to: string.isRequired,
    query: object,
    state: object,
    onEnter: _InternalPropTypes.falsy,
    children: _InternalPropTypes.falsy
  },

/* istanbul ignore next: sanity check */
  render: function render() {
     true ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, '<Redirect> elements are for router configuration only and should not be rendered') : (0, _invariant2.default)(false) : void 0;
  }
});

exports.default = Redirect;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 495 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

exports.createRouterObject = createRouterObject;
exports.createRoutingHistory = createRoutingHistory;

var _deprecateObjectProperties = __webpack_require__(188);

var _deprecateObjectProperties2 = _interopRequireDefault(_deprecateObjectProperties);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function createRouterObject(history, transitionManager) {
  return _extends({}, history, {
    setRouteLeaveHook: transitionManager.listenBeforeLeavingRoute,
    isActive: transitionManager.isActive
  });
}

// deprecated
function createRoutingHistory(history, transitionManager) {
  history = _extends({}, history, transitionManager);

if (process.env.NODE_ENV !== 'production') {
    history = (0, _deprecateObjectProperties2.default)(history, '`props.history` and `context.history` are deprecated. Please use `context.router`. http://tiny.cc/router-contextchanges');
  }

return history;
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 496 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.default = createMemoryHistory;

var _useQueries = __webpack_require__(170);

var _useQueries2 = _interopRequireDefault(_useQueries);

var _useBasename = __webpack_require__(419);

var _useBasename2 = _interopRequireDefault(_useBasename);

var _createMemoryHistory = __webpack_require__(951);

var _createMemoryHistory2 = _interopRequireDefault(_createMemoryHistory);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function createMemoryHistory(options) {
  // signatures and type checking differ between `useRoutes` and
  // `createMemoryHistory`, have to create `memoryHistory` first because
  // `useQueries` doesn't understand the signature
  var memoryHistory = (0, _createMemoryHistory2.default)(options);
  var createHistory = function createHistory() {
    return memoryHistory;
  };
  var history = (0, _useQueries2.default)((0, _useBasename2.default)(createHistory))(options);
  history.__v2_compatible__ = true;
  return history;
}
module.exports = exports['default'];

/***/ }),
/* 497 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

exports.default = function (createHistory) {
  var history = void 0;
  if (canUseDOM) history = (0, _useRouterHistory2.default)(createHistory)();
  return history;
};

var _useRouterHistory = __webpack_require__(499);

var _useRouterHistory2 = _interopRequireDefault(_useRouterHistory);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);

module.exports = exports['default'];

/***/ }),
/* 498 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

exports.default = makeStateWithLocation;

var _deprecateObjectProperties = __webpack_require__(188);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function makeStateWithLocation(state, location) {
  if (process.env.NODE_ENV !== 'production' && _deprecateObjectProperties.canUseMembrane) {
    var stateWithLocation = _extends({}, state);

// I don't use deprecateObjectProperties here because I want to keep the
    // same code path between development and production, in that we just
    // assign extra properties to the copy of the state object in both cases.

var _loop = function _loop(prop) {
      if (!Object.prototype.hasOwnProperty.call(location, prop)) {
        return 'continue';
      }

Object.defineProperty(stateWithLocation, prop, {
        get: function get() {
          process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, 'Accessing location properties directly from the first argument to `getComponent`, `getComponents`, `getChildRoutes`, and `getIndexRoute` is deprecated. That argument is now the router state (`nextState` or `partialNextState`) rather than the location. To access the location, use `nextState.location` or `partialNextState.location`.') : void 0;
          return location[prop];
        }
      });
    };

for (var prop in location) {
      var _ret = _loop(prop);

if (_ret === 'continue') continue;
    }

return stateWithLocation;
  }

return _extends({}, state, location);
}
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 499 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.default = useRouterHistory;

var _useQueries = __webpack_require__(170);

var _useQueries2 = _interopRequireDefault(_useQueries);

var _useBasename = __webpack_require__(419);

var _useBasename2 = _interopRequireDefault(_useBasename);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function useRouterHistory(createHistory) {
  return function (options) {
    var history = (0, _useQueries2.default)((0, _useBasename2.default)(createHistory))(options);
    history.__v2_compatible__ = true;
    return history;
  };
}
module.exports = exports['default'];

/***/ }),
/* 500 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactDom = __webpack_require__(7);

var _reactDom2 = _interopRequireDefault(_reactDom);

var _clamp = __webpack_require__(1272);

var _clamp2 = _interopRequireDefault(_clamp);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function noop() {}
var getDocument = function getDocument(element) {
  return element.ownerDocument;
};

var DraggableMixin = {

propTypes: {
    onChange: _react2.default.PropTypes.func.isRequired,
    max: _react2.default.PropTypes.number
  },

getDefaultProps: function getDefaultProps() {
    return {
      onChange: noop,
      max: 1
    };
  },
  getInitialState: function getInitialState() {
    return {
      active: false
    };
  },
  componentDidMount: function componentDidMount() {
    this.document = getDocument(_reactDom2.default.findDOMNode(this));
    this.rect = this.getBoundingRect();
  },
  startUpdates: function startUpdates(e) {
    var document = this.document;

document.addEventListener("mousemove", this.handleUpdate);
    document.addEventListener("touchmove", this.handleUpdate);
    document.addEventListener("mouseup", this.stopUpdates);
    document.addEventListener("touchend", this.stopUpdates);

e.preventDefault();

var _getPosition = this.getPosition(e);

var x = _getPosition.x;
    var y = _getPosition.y;

this.rect = this.getBoundingRect();
    this.setState({ active: true });
    this.updatePosition(this.rect, x, y);
  },
  handleUpdate: function handleUpdate(e) {
    e.preventDefault();

var _getPosition2 = this.getPosition(e);

var x = _getPosition2.x;
    var y = _getPosition2.y;

this.updatePosition(this.rect, x, y);
  },
  stopUpdates: function stopUpdates() {
    var document = this.document;

document.removeEventListener("mousemove", this.handleUpdate);
    document.removeEventListener("touchmove", this.handleUpdate);
    document.removeEventListener("mouseup", this.stopUpdates);
    document.removeEventListener("touchend", this.stopUpdates);

this.setState({ active: false });
  },
  getPosition: function getPosition(e) {
    if (e.touches) {
      e = e.touches[0];
    }

return {
      x: e.clientX,
      y: e.clientY
    };
  },
  getPercentageValue: function getPercentageValue(value) {
    return value / this.props.max * 100 + "%";
  },
  getScaledValue: function getScaledValue(value) {
    return (0, _clamp2.default)(value, 0, 1) * this.props.max;
  },
  getBoundingRect: function getBoundingRect() {
    return _reactDom2.default.findDOMNode(this).getBoundingClientRect();
  }
};

exports.default = DraggableMixin;

/***/ }),
/* 501 */
/***/ (function(module, exports, __webpack_require__) {

var identity = __webpack_require__(1314);

/**
 * A specialized version of `baseCallback` which only supports `this` binding
 * and specifying the number of arguments to provide to `func`.
 *
 * @private
 * @param {Function} func The function to bind.
 * @param {*} thisArg The `this` binding of `func`.
 * @param {number} [argCount] The number of arguments to provide to `func`.
 * @returns {Function} Returns the callback.
 */
function bindCallback(func, thisArg, argCount) {
  if (typeof func != 'function') {
    return identity;
  }
  if (thisArg === undefined) {
    return func;
  }
  switch (argCount) {
    case 1: return function(value) {
      return func.call(thisArg, value);
    };
    case 3: return function(value, index, collection) {
      return func.call(thisArg, value, index, collection);
    };
    case 4: return function(accumulator, value, index, collection) {
      return func.call(thisArg, accumulator, value, index, collection);
    };
    case 5: return function(value, other, key, object, source) {
      return func.call(thisArg, value, other, key, object, source);
    };
  }
  return function() {
    return func.apply(thisArg, arguments);
  };
}

module.exports = bindCallback;

/***/ }),
/* 502 */
/***/ (function(module, exports, __webpack_require__) {

var isNative = __webpack_require__(1311);

/**
 * Gets the native function at `key` of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {string} key The key of the method to get.
 * @returns {*} Returns the function if it's native, else `undefined`.
 */
function getNative(object, key) {
  var value = object == null ? undefined : object[key];
  return isNative(value) ? value : undefined;
}

module.exports = getNative;

/***/ }),
/* 503 */
/***/ (function(module, exports, __webpack_require__) {

var isArrayLike = __webpack_require__(310),
    isObjectLike = __webpack_require__(143);

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Native method references. */
var propertyIsEnumerable = objectProto.propertyIsEnumerable;

/**
 * Checks if `value` is classified as an `arguments` object.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isArguments(function() { return arguments; }());
 * // => true
 *
 * _.isArguments([1, 2, 3]);
 * // => false
 */
function isArguments(value) {
  return isObjectLike(value) && isArrayLike(value) &&
    hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
}

module.exports = isArguments;

/***/ }),
/* 504 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.default = exports.EXITING = exports.ENTERED = exports.ENTERING = exports.EXITED = exports.UNMOUNTED = void 0;

var PropTypes = _interopRequireWildcard(__webpack_require__(6));

var _react = _interopRequireDefault(__webpack_require__(0));

var _reactDom = _interopRequireDefault(__webpack_require__(7));

var _reactLifecyclesCompat = __webpack_require__(61);

var _PropTypes = __webpack_require__(507);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

exports.EXITING = EXITING;

var Transition =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(Transition, _React$Component);

function Transition(props, context) {
    var _this;

_this = _React$Component.call(this, props, context) || this;
    var parentGroup = context.transitionGroup; // In the context of a TransitionGroup all enters are really appears

var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;
    var initialStatus;
    _this.appearStatus = null;

if (props.in) {
      if (appear) {
        initialStatus = EXITED;
        _this.appearStatus = ENTERING;
      } else {
        initialStatus = ENTERED;
      }
    } else {
      if (props.unmountOnExit || props.mountOnEnter) {
        initialStatus = UNMOUNTED;
      } else {
        initialStatus = EXITED;
      }
    }

_this.state = {
      status: initialStatus
    };
    _this.nextCallback = null;
    return _this;
  }

var _proto = Transition.prototype;

_proto.getChildContext = function getChildContext() {
    return {
      transitionGroup: null // allows for nested Transitions

};
  };

Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {
    var nextIn = _ref.in;

if (nextIn && prevState.status === UNMOUNTED) {
      return {
        status: EXITED
      };
    }

return null;
  }; // getSnapshotBeforeUpdate(prevProps) {
  //   let nextStatus = null
  //   if (prevProps !== this.props) {
  //     const { status } = this.state
  //     if (this.props.in) {
  //       if (status !== ENTERING && status !== ENTERED) {
  //         nextStatus = ENTERING
  //       }
  //     } else {
  //       if (status === ENTERING || status === ENTERED) {
  //         nextStatus = EXITING
  //       }
  //     }
  //   }
  //   return { nextStatus }
  // }

_proto.componentDidMount = function componentDidMount() {
    this.updateStatus(true, this.appearStatus);
  };

_proto.componentDidUpdate = function componentDidUpdate(prevProps) {
    var nextStatus = null;

if (prevProps !== this.props) {
      var status = this.state.status;

if (this.props.in) {
        if (status !== ENTERING && status !== ENTERED) {
          nextStatus = ENTERING;
        }
      } else {
        if (status === ENTERING || status === ENTERED) {
          nextStatus = EXITING;
        }
      }
    }

this.updateStatus(false, nextStatus);
  };

_proto.componentWillUnmount = function componentWillUnmount() {
    this.cancelNextCallback();
  };

_proto.getTimeouts = function getTimeouts() {
    var timeout = this.props.timeout;
    var exit, enter, appear;
    exit = enter = appear = timeout;

if (timeout != null && typeof timeout !== 'number') {
      exit = timeout.exit;
      enter = timeout.enter;
      appear = timeout.appear;
    }

return {
      exit: exit,
      enter: enter,
      appear: appear
    };
  };

_proto.updateStatus = function updateStatus(mounting, nextStatus) {
    if (mounting === void 0) {
      mounting = false;
    }

if (nextStatus !== null) {
      // nextStatus will always be ENTERING or EXITING.
      this.cancelNextCallback();

var node = _reactDom.default.findDOMNode(this);

if (nextStatus === ENTERING) {
        this.performEnter(node, mounting);
      } else {
        this.performExit(node);
      }
    } else if (this.props.unmountOnExit && this.state.status === EXITED) {
      this.setState({
        status: UNMOUNTED
      });
    }
  };

_proto.performEnter = function performEnter(node, mounting) {
    var _this2 = this;

var enter = this.props.enter;
    var appearing = this.context.transitionGroup ? this.context.transitionGroup.isMounting : mounting;
    var timeouts = this.getTimeouts(); // no enter animation skip right to ENTERED
    // if we are mounting and running this it means appear _must_ be set

if (!mounting && !enter) {
      this.safeSetState({
        status: ENTERED
      }, function () {
        _this2.props.onEntered(node);
      });
      return;
    }

this.props.onEnter(node, appearing);
    this.safeSetState({
      status: ENTERING
    }, function () {
      _this2.props.onEntering(node, appearing); // FIXME: appear timeout?

_this2.onTransitionEnd(node, timeouts.enter, function () {
        _this2.safeSetState({
          status: ENTERED
        }, function () {
          _this2.props.onEntered(node, appearing);
        });
      });
    });
  };

_proto.performExit = function performExit(node) {
    var _this3 = this;

var exit = this.props.exit;
    var timeouts = this.getTimeouts(); // no exit animation skip right to EXITED

if (!exit) {
      this.safeSetState({
        status: EXITED
      }, function () {
        _this3.props.onExited(node);
      });
      return;
    }

this.props.onExit(node);
    this.safeSetState({
      status: EXITING
    }, function () {
      _this3.props.onExiting(node);

_this3.onTransitionEnd(node, timeouts.exit, function () {
        _this3.safeSetState({
          status: EXITED
        }, function () {
          _this3.props.onExited(node);
        });
      });
    });
  };

_proto.cancelNextCallback = function cancelNextCallback() {
    if (this.nextCallback !== null) {
      this.nextCallback.cancel();
      this.nextCallback = null;
    }
  };

_proto.safeSetState = function safeSetState(nextState, callback) {
    // This shouldn't be necessary, but there are weird race conditions with
    // setState callbacks and unmounting in testing, so always make sure that
    // we can cancel any pending setState callbacks after we unmount.
    callback = this.setNextCallback(callback);
    this.setState(nextState, callback);
  };

_proto.setNextCallback = function setNextCallback(callback) {
    var _this4 = this;

var active = true;

this.nextCallback = function (event) {
      if (active) {
        active = false;
        _this4.nextCallback = null;
        callback(event);
      }
    };

this.nextCallback.cancel = function () {
      active = false;
    };

return this.nextCallback;
  };

_proto.onTransitionEnd = function onTransitionEnd(node, timeout, handler) {
    this.setNextCallback(handler);

if (node) {
      if (this.props.addEndListener) {
        this.props.addEndListener(node, this.nextCallback);
      }

if (timeout != null) {
        setTimeout(this.nextCallback, timeout);
      }
    } else {
      setTimeout(this.nextCallback, 0);
    }
  };

_proto.render = function render() {
    var status = this.state.status;

if (status === UNMOUNTED) {
      return null;
    }

var _this$props = this.props,
        children = _this$props.children,
        childProps = _objectWithoutPropertiesLoose(_this$props, ["children"]); // filter props for Transtition

delete childProps.in;
    delete childProps.mountOnEnter;
    delete childProps.unmountOnExit;
    delete childProps.appear;
    delete childProps.enter;
    delete childProps.exit;
    delete childProps.timeout;
    delete childProps.addEndListener;
    delete childProps.onEnter;
    delete childProps.onEntering;
    delete childProps.onEntered;
    delete childProps.onExit;
    delete childProps.onExiting;
    delete childProps.onExited;

if (typeof children === 'function') {
      return children(status, childProps);
    }

var child = _react.default.Children.only(children);

return _react.default.cloneElement(child, childProps);
  };

return Transition;
}(_react.default.Component);

Transition.contextTypes = {
  transitionGroup: PropTypes.object
};
Transition.childContextTypes = {
  transitionGroup: function transitionGroup() {}
};
Transition.propTypes = process.env.NODE_ENV !== "production" ? {
  /**
   * A `function` child can be used instead of a React element.
   * This function is called with the current transition status
   * ('entering', 'entered', 'exiting', 'exited', 'unmounted'), which can be used
   * to apply context specific props to a component.
   *
   * ```jsx
   * <Transition timeout={150}>
   *   {(status) => (
   *     <MyComponent className={`fade fade-${status}`} />
   *   )}
   * </Transition>
   * ```
   */
  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,

/**
   * Show the component; triggers the enter or exit states
   */
  in: PropTypes.bool,

/**
   * By default the child component is mounted immediately along with
   * the parent `Transition` component. If you want to "lazy mount" the component on the
   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
   * mounted, even on "exited", unless you also specify `unmountOnExit`.
   */
  mountOnEnter: PropTypes.bool,

/**
   * By default the child component stays mounted after it reaches the `'exited'` state.
   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
   */
  unmountOnExit: PropTypes.bool,

/**
   * Normally a component is not transitioned if it is shown when the `<Transition>` component mounts.
   * If you want to transition on the first mount set `appear` to `true`, and the
   * component will transition in as soon as the `<Transition>` mounts.
   *
   * > Note: there are no specific "appear" states. `appear` only adds an additional `enter` transition.
   */
  appear: PropTypes.bool,

/**
   * Enable or disable enter transitions.
   */
  enter: PropTypes.bool,

/**
   * Enable or disable exit transitions.
   */
  exit: PropTypes.bool,

/**
   * The duration of the transition, in milliseconds.
   * Required unless `addEndListener` is provided
   *
   * You may specify a single timeout for all transitions like: `timeout={500}`,
   * or individually like:
   *
   * ```jsx
   * timeout={{
   *  enter: 300,
   *  exit: 500,
   * }}
   * ```
   *
   * @type {number | { enter?: number, exit?: number }}
   */
  timeout: function timeout(props) {
    var pt = process.env.NODE_ENV !== "production" ? _PropTypes.timeoutsShape : {};;
    if (!props.addEndListener) pt = pt.isRequired;

for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }

return pt.apply(void 0, [props].concat(args));
  },

/**
   * Add a custom transition end trigger. Called with the transitioning
   * DOM node and a `done` callback. Allows for more fine grained transition end
   * logic. **Note:** Timeouts are still used as a fallback if provided.
   *
   * ```jsx
   * addEndListener={(node, done) => {
   *   // use the css transitionend event to mark the finish of a transition
   *   node.addEventListener('transitionend', done, false);
   * }}
   * ```
   */
  addEndListener: PropTypes.func,

/**
   * Callback fired before the "entering" status is applied. An extra parameter
   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
   *
   * @type Function(node: HtmlElement, isAppearing: bool) -> void
   */
  onEnter: PropTypes.func,

/**
   * Callback fired after the "entering" status is applied. An extra parameter
   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
   *
   * @type Function(node: HtmlElement, isAppearing: bool)
   */
  onEntering: PropTypes.func,

/**
   * Callback fired after the "entered" status is applied. An extra parameter
   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
   *
   * @type Function(node: HtmlElement, isAppearing: bool) -> void
   */
  onEntered: PropTypes.func,

/**
   * Callback fired before the "exiting" status is applied.
   *
   * @type Function(node: HtmlElement) -> void
   */
  onExit: PropTypes.func,

/**
   * Callback fired after the "exiting" status is applied.
   *
   * @type Function(node: HtmlElement) -> void
   */
  onExiting: PropTypes.func,

/**
   * Callback fired after the "exited" status is applied.
   *
   * @type Function(node: HtmlElement) -> void
   */
  onExited: PropTypes.func // Name the function so it is clearer in the documentation

} : {};

function noop() {}

Transition.defaultProps = {
  in: false,
  mountOnEnter: false,
  unmountOnExit: false,
  appear: false,
  enter: true,
  exit: true,
  onEnter: noop,
  onEntering: noop,
  onEntered: noop,
  onExit: noop,
  onExiting: noop,
  onExited: noop
};
Transition.UNMOUNTED = 0;
Transition.EXITED = 1;
Transition.ENTERING = 2;
Transition.ENTERED = 3;
Transition.EXITING = 4;

var _default = (0, _reactLifecyclesCompat.polyfill)(Transition);

exports.default = _default;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 505 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.default = void 0;

var _propTypes = _interopRequireDefault(__webpack_require__(6));

var _react = _interopRequireDefault(__webpack_require__(0));

var _reactLifecyclesCompat = __webpack_require__(61);

var _ChildMapping = __webpack_require__(1317);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

var values = Object.values || function (obj) {
  return Object.keys(obj).map(function (k) {
    return obj[k];
  });
};

var defaultProps = {
  component: 'div',
  childFactory: function childFactory(child) {
    return child;
  }
  /**
   * The `<TransitionGroup>` component manages a set of transition components
   * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition
   * components, `<TransitionGroup>` is a state machine for managing the mounting
   * and unmounting of components over time.
   *
   * Consider the example below. As items are removed or added to the TodoList the
   * `in` prop is toggled automatically by the `<TransitionGroup>`.
   *
   * Note that `<TransitionGroup>`  does not define any animation behavior!
   * Exactly _how_ a list item animates is up to the individual transition
   * component. This means you can mix and match animations across different list
   * items.
   */

};

var TransitionGroup =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(TransitionGroup, _React$Component);

function TransitionGroup(props, context) {
    var _this;

_this = _React$Component.call(this, props, context) || this;

var handleExited = _this.handleExited.bind(_assertThisInitialized(_assertThisInitialized(_this))); // Initial children should all be entering, dependent on appear

_this.state = {
      handleExited: handleExited,
      firstRender: true
    };
    return _this;
  }

var _proto = TransitionGroup.prototype;

_proto.getChildContext = function getChildContext() {
    return {
      transitionGroup: {
        isMounting: !this.appeared
      }
    };
  };

_proto.componentDidMount = function componentDidMount() {
    this.appeared = true;
    this.mounted = true;
  };

_proto.componentWillUnmount = function componentWillUnmount() {
    this.mounted = false;
  };

TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {
    var prevChildMapping = _ref.children,
        handleExited = _ref.handleExited,
        firstRender = _ref.firstRender;
    return {
      children: firstRender ? (0, _ChildMapping.getInitialChildMapping)(nextProps, handleExited) : (0, _ChildMapping.getNextChildMapping)(nextProps, prevChildMapping, handleExited),
      firstRender: false
    };
  };

_proto.handleExited = function handleExited(child, node) {
    var currentChildMapping = (0, _ChildMapping.getChildMapping)(this.props.children);
    if (child.key in currentChildMapping) return;

if (child.props.onExited) {
      child.props.onExited(node);
    }

if (this.mounted) {
      this.setState(function (state) {
        var children = _extends({}, state.children);

delete children[child.key];
        return {
          children: children
        };
      });
    }
  };

_proto.render = function render() {
    var _this$props = this.props,
        Component = _this$props.component,
        childFactory = _this$props.childFactory,
        props = _objectWithoutPropertiesLoose(_this$props, ["component", "childFactory"]);

var children = values(this.state.children).map(childFactory);
    delete props.appear;
    delete props.enter;
    delete props.exit;

if (Component === null) {
      return children;
    }

return _react.default.createElement(Component, props, children);
  };

return TransitionGroup;
}(_react.default.Component);

TransitionGroup.childContextTypes = {
  transitionGroup: _propTypes.default.object.isRequired
};
TransitionGroup.propTypes = process.env.NODE_ENV !== "production" ? {
  /**
   * `<TransitionGroup>` renders a `<div>` by default. You can change this
   * behavior by providing a `component` prop.
   * If you use React v16+ and would like to avoid a wrapping `<div>` element
   * you can pass in `component={null}`. This is useful if the wrapping div
   * borks your css styles.
   */
  component: _propTypes.default.any,

/**
   * A set of `<Transition>` components, that are toggled `in` and out as they
   * leave. the `<TransitionGroup>` will inject specific transition props, so
   * remember to spread them through if you are wrapping the `<Transition>` as
   * with our `<Fade>` example.
   */
  children: _propTypes.default.node,

/**
   * A convenience prop that enables or disables appear animations
   * for all children. Note that specifying this will override any defaults set
   * on individual children Transitions.
   */
  appear: _propTypes.default.bool,

/**
   * A convenience prop that enables or disables enter animations
   * for all children. Note that specifying this will override any defaults set
   * on individual children Transitions.
   */
  enter: _propTypes.default.bool,

/**
   * A convenience prop that enables or disables exit animations
   * for all children. Note that specifying this will override any defaults set
   * on individual children Transitions.
   */
  exit: _propTypes.default.bool,

/**
   * You may need to apply reactive updates to a child as it is exiting.
   * This is generally done by using `cloneElement` however in the case of an exiting
   * child the element has already been removed and not accessible to the consumer.
   *
   * If you do need to update a child as it leaves you can provide a `childFactory`
   * to wrap every child, even the ones that are leaving.
   *
   * @type Function(child: ReactElement) -> ReactElement
   */
  childFactory: _propTypes.default.func
} : {};
TransitionGroup.defaultProps = defaultProps;

var _default = (0, _reactLifecyclesCompat.polyfill)(TransitionGroup);

exports.default = _default;
module.exports = exports["default"];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 506 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _CSSTransition = _interopRequireDefault(__webpack_require__(1315));

var _ReplaceTransition = _interopRequireDefault(__webpack_require__(1316));

var _TransitionGroup = _interopRequireDefault(__webpack_require__(505));

var _Transition = _interopRequireDefault(__webpack_require__(504));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

module.exports = {
  Transition: _Transition.default,
  TransitionGroup: _TransitionGroup.default,
  ReplaceTransition: _ReplaceTransition.default,
  CSSTransition: _CSSTransition.default
};

/***/ }),
/* 507 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.classNamesShape = exports.timeoutsShape = void 0;

var _propTypes = _interopRequireDefault(__webpack_require__(6));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ }),
/* 508 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Default CellMeasurer `cellSizeCache` implementation.
 * Permanently caches all cell sizes (identified by column and row index) unless explicitly cleared.
 * Can be configured to handle uniform cell widths and/or heights as a way of optimizing certain use cases.
 */
var CellSizeCache = function () {
  function CellSizeCache() {
    var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

var _ref$uniformRowHeight = _ref.uniformRowHeight;
    var uniformRowHeight = _ref$uniformRowHeight === undefined ? false : _ref$uniformRowHeight;
    var _ref$uniformColumnWid = _ref.uniformColumnWidth;
    var uniformColumnWidth = _ref$uniformColumnWid === undefined ? false : _ref$uniformColumnWid;

_classCallCheck(this, CellSizeCache);

this._uniformRowHeight = uniformRowHeight;
    this._uniformColumnWidth = uniformColumnWidth;

this._cachedColumnWidths = {};
    this._cachedRowHeights = {};
  }

_createClass(CellSizeCache, [{
    key: "clearAllColumnWidths",
    value: function clearAllColumnWidths() {
      this._cachedColumnWidth = undefined;
      this._cachedColumnWidths = {};
    }
  }, {
    key: "clearAllRowHeights",
    value: function clearAllRowHeights() {
      this._cachedRowHeight = undefined;
      this._cachedRowHeights = {};
    }
  }, {
    key: "clearColumnWidth",
    value: function clearColumnWidth(index) {
      this._cachedColumnWidth = undefined;

delete this._cachedColumnWidths[index];
    }
  }, {
    key: "clearRowHeight",
    value: function clearRowHeight(index) {
      this._cachedRowHeight = undefined;

delete this._cachedRowHeights[index];
    }
  }, {
    key: "getColumnWidth",
    value: function getColumnWidth(index) {
      return this._uniformColumnWidth ? this._cachedColumnWidth : this._cachedColumnWidths[index];
    }
  }, {
    key: "getRowHeight",
    value: function getRowHeight(index) {
      return this._uniformRowHeight ? this._cachedRowHeight : this._cachedRowHeights[index];
    }
  }, {
    key: "hasColumnWidth",
    value: function hasColumnWidth(index) {
      return this._uniformColumnWidth ? !!this._cachedColumnWidth : !!this._cachedColumnWidths[index];
    }
  }, {
    key: "hasRowHeight",
    value: function hasRowHeight(index) {
      return this._uniformRowHeight ? !!this._cachedRowHeight : !!this._cachedRowHeights[index];
    }
  }, {
    key: "setColumnWidth",
    value: function setColumnWidth(index, width) {
      this._cachedColumnWidth = width;
      this._cachedColumnWidths[index] = width;
    }
  }, {
    key: "setRowHeight",
    value: function setRowHeight(index, height) {
      this._cachedRowHeight = height;
      this._cachedRowHeights[index] = height;
    }
  }]);

return CellSizeCache;
}();

exports.default = CellSizeCache;

/***/ }),
/* 509 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = defaultCellRangeRenderer;

/**
 * Default implementation of cellRangeRenderer used by Grid.
 * This renderer supports cell-caching while the user is scrolling.
 */
function defaultCellRangeRenderer(_ref) {
  var cellCache = _ref.cellCache;
  var cellRenderer = _ref.cellRenderer;
  var columnSizeAndPositionManager = _ref.columnSizeAndPositionManager;
  var columnStartIndex = _ref.columnStartIndex;
  var columnStopIndex = _ref.columnStopIndex;
  var horizontalOffsetAdjustment = _ref.horizontalOffsetAdjustment;
  var isScrolling = _ref.isScrolling;
  var rowSizeAndPositionManager = _ref.rowSizeAndPositionManager;
  var rowStartIndex = _ref.rowStartIndex;
  var rowStopIndex = _ref.rowStopIndex;
  var scrollLeft = _ref.scrollLeft;
  var scrollTop = _ref.scrollTop;
  var verticalOffsetAdjustment = _ref.verticalOffsetAdjustment;

var renderedCells = [];

for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {
    var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex);

for (var columnIndex = columnStartIndex; columnIndex <= columnStopIndex; columnIndex++) {
      var columnDatum = columnSizeAndPositionManager.getSizeAndPositionOfCell(columnIndex);
      var key = rowIndex + '-' + columnIndex;
      var style = {
        height: rowDatum.size,
        left: columnDatum.offset + horizontalOffsetAdjustment,
        position: 'absolute',
        top: rowDatum.offset + verticalOffsetAdjustment,
        width: columnDatum.size
      };

var cellRendererParams = {
        columnIndex: columnIndex,
        isScrolling: isScrolling,
        key: key,
        rowIndex: rowIndex,
        style: style
      };

var renderedCell = void 0;

// Avoid re-creating cells while scrolling.
      // This can lead to the same cell being created many times and can cause performance issues for "heavy" cells.
      // If a scroll is in progress- cache and reuse cells.
      // This cache will be thrown away once scrolling completes.
      // However if we are scaling scroll positions and sizes, we should also avoid caching.
      // This is because the offset changes slightly as scroll position changes and caching leads to stale values.
      // For more info refer to issue #395
      if (isScrolling && !horizontalOffsetAdjustment && !verticalOffsetAdjustment) {
        if (!cellCache[key]) {
          cellCache[key] = cellRenderer(cellRendererParams);
        }
        renderedCell = cellCache[key];
        // If the user is no longer scrolling, don't cache cells.
        // This makes dynamic cell content difficult for users and would also lead to a heavier memory footprint.
      } else {
        renderedCell = cellRenderer(cellRendererParams);
      }

if (renderedCell == null || renderedCell === false) {
        continue;
      }

renderedCells.push(renderedCell);
    }
  }

return renderedCells;
}

/***/ }),
/* 510 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _defaultHeaderRenderer = __webpack_require__(514);

var _defaultHeaderRenderer2 = _interopRequireDefault(_defaultHeaderRenderer);

var _defaultCellRenderer = __webpack_require__(513);

var _defaultCellRenderer2 = _interopRequireDefault(_defaultCellRenderer);

var _defaultCellDataGetter = __webpack_require__(512);

var _defaultCellDataGetter2 = _interopRequireDefault(_defaultCellDataGetter);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Describes the header and cell contents of a table column.
 */
var Column = function (_Component) {
  _inherits(Column, _Component);

function Column() {
    _classCallCheck(this, Column);

return _possibleConstructorReturn(this, (Column.__proto__ || Object.getPrototypeOf(Column)).apply(this, arguments));
  }

return Column;
}(_react.Component);

Column.defaultProps = {
  cellDataGetter: _defaultCellDataGetter2.default,
  cellRenderer: _defaultCellRenderer2.default,
  flexGrow: 0,
  flexShrink: 1,
  headerRenderer: _defaultHeaderRenderer2.default,
  style: {}
};
Column.propTypes = {
  /** Optional aria-label value to set on the column header */
  'aria-label': _react.PropTypes.string,

/**
   * Callback responsible for returning a cell's data, given its :dataKey
   * ({ columnData: any, dataKey: string, rowData: any }): any
   */
  cellDataGetter: _react.PropTypes.func,

/**
   * Callback responsible for rendering a cell's contents.
   * ({ cellData: any, columnData: any, dataKey: string, rowData: any, rowIndex: number }): node
   */
  cellRenderer: _react.PropTypes.func,

/** Optional CSS class to apply to cell */
  className: _react.PropTypes.string,

/** Optional additional data passed to this column's :cellDataGetter */
  columnData: _react.PropTypes.object,

/** Uniquely identifies the row-data attribute correspnding to this cell */
  dataKey: _react.PropTypes.any.isRequired,

/** If sort is enabled for the table at large, disable it for this column */
  disableSort: _react.PropTypes.bool,

/** Flex grow style; defaults to 0 */
  flexGrow: _react.PropTypes.number,

/** Flex shrink style; defaults to 1 */
  flexShrink: _react.PropTypes.number,

/** Optional CSS class to apply to this column's header */
  headerClassName: _react.PropTypes.string,

/**
   * Optional callback responsible for rendering a column header contents.
   * ({ columnData: object, dataKey: string, disableSort: boolean, label: string, sortBy: string, sortDirection: string }): PropTypes.node
   */
  headerRenderer: _react.PropTypes.func.isRequired,

/** Header label for this column */
  label: _react.PropTypes.string,

/** Maximum width of column; this property will only be used if :flexGrow is > 0. */
  maxWidth: _react.PropTypes.number,

/** Minimum width of column. */
  minWidth: _react.PropTypes.number,

/** Optional inline style to apply to cell */
  style: _react.PropTypes.object,

/** Flex basis (width) for this column; This value can grow or shrink based on :flexGrow and :flexShrink properties. */
  width: _react.PropTypes.number.isRequired
};
exports.default = Column;

/***/ }),
/* 511 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = SortIndicator;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _SortDirection = __webpack_require__(313);

var _SortDirection2 = _interopRequireDefault(_SortDirection);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Displayed beside a header to indicate that a Table is currently sorted by this column.
 */
function SortIndicator(_ref) {
  var sortDirection = _ref.sortDirection;

var classNames = (0, _classnames2.default)('ReactVirtualized__Table__sortableHeaderIcon', {
    'ReactVirtualized__Table__sortableHeaderIcon--ASC': sortDirection === _SortDirection2.default.ASC,
    'ReactVirtualized__Table__sortableHeaderIcon--DESC': sortDirection === _SortDirection2.default.DESC
  });

return _react2.default.createElement(
    'svg',
    {
      className: classNames,
      width: 18,
      height: 18,
      viewBox: '0 0 24 24'
    },
    sortDirection === _SortDirection2.default.ASC ? _react2.default.createElement('path', { d: 'M7 14l5-5 5 5z' }) : _react2.default.createElement('path', { d: 'M7 10l5 5 5-5z' }),
    _react2.default.createElement('path', { d: 'M0 0h24v24H0z', fill: 'none' })
  );
}
SortIndicator.propTypes = {
  sortDirection: _react.PropTypes.oneOf([_SortDirection2.default.ASC, _SortDirection2.default.DESC])
};

/***/ }),
/* 512 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = defaultCellDataGetter;

/**
 * Default accessor for returning a cell value for a given attribute.
 * This function expects to operate on either a vanilla Object or an Immutable Map.
 * You should override the column's cellDataGetter if your data is some other type of object.
 */
function defaultCellDataGetter(_ref) {
  var columnData = _ref.columnData;
  var dataKey = _ref.dataKey;
  var rowData = _ref.rowData;

if (rowData.get instanceof Function) {
    return rowData.get(dataKey);
  } else {
    return rowData[dataKey];
  }
}

/***/ }),
/* 513 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = defaultCellRenderer;

/**
 * Default cell renderer that displays an attribute as a simple string
 * You should override the column's cellRenderer if your data is some other type of object.
 */
function defaultCellRenderer(_ref) {
  var cellData = _ref.cellData;
  var cellDataKey = _ref.cellDataKey;
  var columnData = _ref.columnData;
  var rowData = _ref.rowData;
  var rowIndex = _ref.rowIndex;

if (cellData == null) {
    return '';
  } else {
    return String(cellData);
  }
}

/***/ }),
/* 514 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = defaultHeaderRenderer;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _SortIndicator = __webpack_require__(511);

var _SortIndicator2 = _interopRequireDefault(_SortIndicator);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Default table header renderer.
 */
function defaultHeaderRenderer(_ref) {
  var columnData = _ref.columnData;
  var dataKey = _ref.dataKey;
  var disableSort = _ref.disableSort;
  var label = _ref.label;
  var sortBy = _ref.sortBy;
  var sortDirection = _ref.sortDirection;

var showSortIndicator = sortBy === dataKey;
  var children = [_react2.default.createElement(
    'span',
    {
      className: 'ReactVirtualized__Table__headerTruncatedText',
      key: 'label',
      title: label
    },
    label
  )];

if (showSortIndicator) {
    children.push(_react2.default.createElement(_SortIndicator2.default, {
      key: 'SortIndicator',
      sortDirection: sortDirection
    }));
  }

return children;
}

/***/ }),
/* 515 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

exports.default = defaultRowRenderer;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Default row renderer for Table.
 */
function defaultRowRenderer(_ref) {
  var className = _ref.className;
  var columns = _ref.columns;
  var index = _ref.index;
  var isScrolling = _ref.isScrolling;
  var key = _ref.key;
  var onRowClick = _ref.onRowClick;
  var onRowDoubleClick = _ref.onRowDoubleClick;
  var onRowMouseOver = _ref.onRowMouseOver;
  var onRowMouseOut = _ref.onRowMouseOut;
  var rowData = _ref.rowData;
  var style = _ref.style;

var a11yProps = {};

if (onRowClick || onRowDoubleClick || onRowMouseOver || onRowMouseOut) {
    a11yProps['aria-label'] = 'row';
    a11yProps.role = 'row';
    a11yProps.tabIndex = 0;

if (onRowClick) {
      a11yProps.onClick = function () {
        return onRowClick({ index: index });
      };
    }
    if (onRowDoubleClick) {
      a11yProps.onDoubleClick = function () {
        return onRowDoubleClick({ index: index });
      };
    }
    if (onRowMouseOut) {
      a11yProps.onMouseOut = function () {
        return onRowMouseOut({ index: index });
      };
    }
    if (onRowMouseOver) {
      a11yProps.onMouseOver = function () {
        return onRowMouseOver({ index: index });
      };
    }
  }

return _react2.default.createElement(
    'div',
    _extends({}, a11yProps, {
      className: className,
      key: key,
      style: style
    }),
    columns
  );
}

/***/ }),
/* 516 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.registerScrollListener = registerScrollListener;
exports.unregisterScrollListener = unregisterScrollListener;
var mountedInstances = [];
var originalBodyPointerEvents = null;
var disablePointerEventsTimeoutId = null;

/**
 * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.
 * This improves performance and makes scrolling smoother.
 */
var IS_SCROLLING_TIMEOUT = exports.IS_SCROLLING_TIMEOUT = 150;

function enablePointerEventsIfDisabled() {
  if (disablePointerEventsTimeoutId) {
    disablePointerEventsTimeoutId = null;

document.body.style.pointerEvents = originalBodyPointerEvents;

originalBodyPointerEvents = null;
  }
}

function enablePointerEventsAfterDelayCallback() {
  enablePointerEventsIfDisabled();
  mountedInstances.forEach(function (component) {
    return component._enablePointerEventsAfterDelayCallback();
  });
}

function enablePointerEventsAfterDelay() {
  if (disablePointerEventsTimeoutId) {
    clearTimeout(disablePointerEventsTimeoutId);
  }

disablePointerEventsTimeoutId = setTimeout(enablePointerEventsAfterDelayCallback, IS_SCROLLING_TIMEOUT);
}

function onScrollWindow(event) {
  if (originalBodyPointerEvents == null) {
    originalBodyPointerEvents = document.body.style.pointerEvents;

document.body.style.pointerEvents = 'none';

enablePointerEventsAfterDelay();
  }
  mountedInstances.forEach(function (component) {
    return component._onScrollWindow(event);
  });
}

function registerScrollListener(component) {
  if (!mountedInstances.length) {
    window.addEventListener('scroll', onScrollWindow);
  }
  mountedInstances.push(component);
}

/***/ }),
/* 517 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export DEFAULT_SCROLLING_RESET_TIME_INTERVAL */
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_get_prototype_of__ = __webpack_require__(384);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_get_prototype_of___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_get_prototype_of__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__utils_calculateSizeAndPositionDataAndUpdateScrollOffset__ = __webpack_require__(1353);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__utils_ScalingCellSizeAndPositionManager__ = __webpack_require__(1352);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__utils_createCallbackMemoizer__ = __webpack_require__(1356);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__ = __webpack_require__(1354);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12_dom_helpers_util_scrollbarSize__ = __webpack_require__(316);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12_dom_helpers_util_scrollbarSize___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_12_dom_helpers_util_scrollbarSize__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13_react_addons_shallow_compare__ = __webpack_require__(36);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13_react_addons_shallow_compare___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_13_react_addons_shallow_compare__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14__utils_updateScrollIndexHelper__ = __webpack_require__(1355);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_15__defaultCellRangeRenderer__ = __webpack_require__(518);

/**
 * Specifies the number of miliseconds during which to disable pointer events while a scroll is in progress.
 * This improves performance and makes scrolling smoother.
 */
var DEFAULT_SCROLLING_RESET_TIME_INTERVAL = 150;

/**
 * Controls whether the Grid updates the DOM element's scrollLeft/scrollTop based on the current state or just observes it.
 * This prevents Grid from interrupting mouse-wheel animations (see issue #2).
 */
var SCROLL_POSITION_CHANGE_REASONS = {
  OBSERVED: 'observed',
  REQUESTED: 'requested'
};

/**
 * Renders tabular data with virtualization along the vertical and horizontal axes.
 * Row heights and column widths must be known ahead of time and specified as properties.
 */

var Grid = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Grid, _Component);

function Grid(props, context) {
    __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Grid);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Grid.__proto__ || __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_get_prototype_of___default()(Grid)).call(this, props, context));

_this.state = {
      isScrolling: false,
      scrollDirectionHorizontal: __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["a" /* SCROLL_DIRECTION_FIXED */],
      scrollDirectionVertical: __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["a" /* SCROLL_DIRECTION_FIXED */],
      scrollLeft: 0,
      scrollTop: 0
    };

// Invokes onSectionRendered callback only when start/stop row or column indices change
    _this._onGridRenderedMemoizer = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_10__utils_createCallbackMemoizer__["a" /* default */])();
    _this._onScrollMemoizer = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_10__utils_createCallbackMemoizer__["a" /* default */])(false);

// Bind functions to instance so they don't lose context when passed around
    _this._enablePointerEventsAfterDelayCallback = _this._enablePointerEventsAfterDelayCallback.bind(_this);
    _this._invokeOnGridRenderedHelper = _this._invokeOnGridRenderedHelper.bind(_this);
    _this._onScroll = _this._onScroll.bind(_this);
    _this._updateScrollLeftForScrollToColumn = _this._updateScrollLeftForScrollToColumn.bind(_this);
    _this._updateScrollTopForScrollToRow = _this._updateScrollTopForScrollToRow.bind(_this);

_this._columnWidthGetter = _this._wrapSizeGetter(props.columnWidth);
    _this._rowHeightGetter = _this._wrapSizeGetter(props.rowHeight);

_this._columnSizeAndPositionManager = new __WEBPACK_IMPORTED_MODULE_9__utils_ScalingCellSizeAndPositionManager__["a" /* default */]({
      cellCount: props.columnCount,
      cellSizeGetter: function cellSizeGetter(index) {
        return _this._columnWidthGetter(index);
      },
      estimatedCellSize: _this._getEstimatedColumnSize(props)
    });
    _this._rowSizeAndPositionManager = new __WEBPACK_IMPORTED_MODULE_9__utils_ScalingCellSizeAndPositionManager__["a" /* default */]({
      cellCount: props.rowCount,
      cellSizeGetter: function cellSizeGetter(index) {
        return _this._rowHeightGetter(index);
      },
      estimatedCellSize: _this._getEstimatedRowSize(props)
    });

// See defaultCellRangeRenderer() for more information on the usage of this cache
    _this._cellCache = {};
    return _this;
  }

/**
   * Pre-measure all columns and rows in a Grid.
   * Typically cells are only measured as needed and estimated sizes are used for cells that have not yet been measured.
   * This method ensures that the next call to getTotalSize() returns an exact size (as opposed to just an estimated one).
   */

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Grid, [{
    key: 'measureAllCells',
    value: function measureAllCells() {
      var _props = this.props;
      var columnCount = _props.columnCount;
      var rowCount = _props.rowCount;

this._columnSizeAndPositionManager.getSizeAndPositionOfCell(columnCount - 1);
      this._rowSizeAndPositionManager.getSizeAndPositionOfCell(rowCount - 1);
    }

/**
     * Forced recompute of row heights and column widths.
     * This function should be called if dynamic column or row sizes have changed but nothing else has.
     * Since Grid only receives :columnCount and :rowCount it has no way of detecting when the underlying data changes.
     */

}, {
    key: 'recomputeGridSize',
    value: function recomputeGridSize() {
      var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

var _ref$columnIndex = _ref.columnIndex;
      var columnIndex = _ref$columnIndex === undefined ? 0 : _ref$columnIndex;
      var _ref$rowIndex = _ref.rowIndex;
      var rowIndex = _ref$rowIndex === undefined ? 0 : _ref$rowIndex;

this._columnSizeAndPositionManager.resetCell(columnIndex);
      this._rowSizeAndPositionManager.resetCell(rowIndex);

// Clear cell cache in case we are scrolling;
      // Invalid row heights likely mean invalid cached content as well.
      this._cellCache = {};

this.forceUpdate();
    }
  }, {
    key: 'componentDidMount',
    value: function componentDidMount() {
      var _props2 = this.props;
      var scrollLeft = _props2.scrollLeft;
      var scrollToColumn = _props2.scrollToColumn;
      var scrollTop = _props2.scrollTop;
      var scrollToRow = _props2.scrollToRow;

// If this component was first rendered server-side, scrollbar size will be undefined.
      // In that event we need to remeasure.

if (!this._scrollbarSizeMeasured) {
        this._scrollbarSize = __WEBPACK_IMPORTED_MODULE_12_dom_helpers_util_scrollbarSize___default()();
        this._scrollbarSizeMeasured = true;
        this.setState({});
      }

if (scrollLeft >= 0 || scrollTop >= 0) {
        this._setScrollPosition({ scrollLeft: scrollLeft, scrollTop: scrollTop });
      }

if (scrollToColumn >= 0 || scrollToRow >= 0) {
        this._updateScrollLeftForScrollToColumn();
        this._updateScrollTopForScrollToRow();
      }

// Update onRowsRendered callback
      this._invokeOnGridRenderedHelper();

// Initialize onScroll callback
      this._invokeOnScrollMemoizer({
        scrollLeft: scrollLeft || 0,
        scrollTop: scrollTop || 0,
        totalColumnsWidth: this._columnSizeAndPositionManager.getTotalSize(),
        totalRowsHeight: this._rowSizeAndPositionManager.getTotalSize()
      });
    }

/**
     * @private
     * This method updates scrollLeft/scrollTop in state for the following conditions:
     * 1) New scroll-to-cell props have been set
     */

}, {
    key: 'componentDidUpdate',
    value: function componentDidUpdate(prevProps, prevState) {
      var _this2 = this;

var _props3 = this.props;
      var autoHeight = _props3.autoHeight;
      var columnCount = _props3.columnCount;
      var height = _props3.height;
      var rowCount = _props3.rowCount;
      var scrollToAlignment = _props3.scrollToAlignment;
      var scrollToColumn = _props3.scrollToColumn;
      var scrollToRow = _props3.scrollToRow;
      var width = _props3.width;
      var _state = this.state;
      var scrollLeft = _state.scrollLeft;
      var scrollPositionChangeReason = _state.scrollPositionChangeReason;
      var scrollTop = _state.scrollTop;

// Handle edge case where column or row count has only just increased over 0.
      // In this case we may have to restore a previously-specified scroll offset.
      // For more info see bvaughn/react-virtualized/issues/218

var columnOrRowCountJustIncreasedFromZero = columnCount > 0 && prevProps.columnCount === 0 || rowCount > 0 && prevProps.rowCount === 0;

// Make sure requested changes to :scrollLeft or :scrollTop get applied.
      // Assigning to scrollLeft/scrollTop tells the browser to interrupt any running scroll animations,
      // And to discard any pending async changes to the scroll position that may have happened in the meantime (e.g. on a separate scrolling thread).
      // So we only set these when we require an adjustment of the scroll position.
      // See issue #2 for more information.
      if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {
        if (scrollLeft >= 0 && (scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft || columnOrRowCountJustIncreasedFromZero)) {
          this._scrollingContainer.scrollLeft = scrollLeft;
        }

// @TRICKY :autoHeight property instructs Grid to leave :scrollTop management to an external HOC (eg WindowScroller).
        // In this case we should avoid checking scrollingContainer.scrollTop since it forces layout/flow.
        if (!autoHeight && scrollTop >= 0 && (scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop || columnOrRowCountJustIncreasedFromZero)) {
          this._scrollingContainer.scrollTop = scrollTop;
        }
      }

// Update scroll offsets if the current :scrollToColumn or :scrollToRow values requires it
      // @TODO Do we also need this check or can the one in componentWillUpdate() suffice?
      __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_14__utils_updateScrollIndexHelper__["a" /* default */])({
        cellSizeAndPositionManager: this._columnSizeAndPositionManager,
        previousCellsCount: prevProps.columnCount,
        previousCellSize: prevProps.columnWidth,
        previousScrollToAlignment: prevProps.scrollToAlignment,
        previousScrollToIndex: prevProps.scrollToColumn,
        previousSize: prevProps.width,
        scrollOffset: scrollLeft,
        scrollToAlignment: scrollToAlignment,
        scrollToIndex: scrollToColumn,
        size: width,
        updateScrollIndexCallback: function updateScrollIndexCallback(scrollToColumn) {
          return _this2._updateScrollLeftForScrollToColumn(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, _this2.props, { scrollToColumn: scrollToColumn }));
        }
      });
      __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_14__utils_updateScrollIndexHelper__["a" /* default */])({
        cellSizeAndPositionManager: this._rowSizeAndPositionManager,
        previousCellsCount: prevProps.rowCount,
        previousCellSize: prevProps.rowHeight,
        previousScrollToAlignment: prevProps.scrollToAlignment,
        previousScrollToIndex: prevProps.scrollToRow,
        previousSize: prevProps.height,
        scrollOffset: scrollTop,
        scrollToAlignment: scrollToAlignment,
        scrollToIndex: scrollToRow,
        size: height,
        updateScrollIndexCallback: function updateScrollIndexCallback(scrollToRow) {
          return _this2._updateScrollTopForScrollToRow(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, _this2.props, { scrollToRow: scrollToRow }));
        }
      });

// Update onRowsRendered callback if start/stop indices have changed
      this._invokeOnGridRenderedHelper();

// Changes to :scrollLeft or :scrollTop should also notify :onScroll listeners
      if (scrollLeft !== prevState.scrollLeft || scrollTop !== prevState.scrollTop) {
        var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize();
        var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize();

this._invokeOnScrollMemoizer({ scrollLeft: scrollLeft, scrollTop: scrollTop, totalColumnsWidth: totalColumnsWidth, totalRowsHeight: totalRowsHeight });
      }
    }
  }, {
    key: 'componentWillMount',
    value: function componentWillMount() {
      // If this component is being rendered server-side, getScrollbarSize() will return undefined.
      // We handle this case in componentDidMount()
      this._scrollbarSize = __WEBPACK_IMPORTED_MODULE_12_dom_helpers_util_scrollbarSize___default()();
      if (this._scrollbarSize === undefined) {
        this._scrollbarSizeMeasured = false;
        this._scrollbarSize = 0;
      } else {
        this._scrollbarSizeMeasured = true;
      }

this._calculateChildrenToRender();
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      if (this._disablePointerEventsTimeoutId) {
        clearTimeout(this._disablePointerEventsTimeoutId);
      }
    }

/**
     * @private
     * This method updates scrollLeft/scrollTop in state for the following conditions:
     * 1) Empty content (0 rows or columns)
     * 2) New scroll props overriding the current state
     * 3) Cells-count or cells-size has changed, making previous scroll offsets invalid
     */

}, {
    key: 'componentWillUpdate',
    value: function componentWillUpdate(nextProps, nextState) {
      var _this3 = this;

if (nextProps.columnCount === 0 && nextState.scrollLeft !== 0 || nextProps.rowCount === 0 && nextState.scrollTop !== 0) {
        this._setScrollPosition({
          scrollLeft: 0,
          scrollTop: 0
        });
      } else if (nextProps.scrollLeft !== this.props.scrollLeft || nextProps.scrollTop !== this.props.scrollTop) {
        this._setScrollPosition({
          scrollLeft: nextProps.scrollLeft,
          scrollTop: nextProps.scrollTop
        });
      }

this._columnWidthGetter = this._wrapSizeGetter(nextProps.columnWidth);
      this._rowHeightGetter = this._wrapSizeGetter(nextProps.rowHeight);

this._columnSizeAndPositionManager.configure({
        cellCount: nextProps.columnCount,
        estimatedCellSize: this._getEstimatedColumnSize(nextProps)
      });
      this._rowSizeAndPositionManager.configure({
        cellCount: nextProps.rowCount,
        estimatedCellSize: this._getEstimatedRowSize(nextProps)
      });

// Update scroll offsets if the size or number of cells have changed, invalidating the previous value
      __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils_calculateSizeAndPositionDataAndUpdateScrollOffset__["a" /* default */])({
        cellCount: this.props.columnCount,
        cellSize: this.props.columnWidth,
        computeMetadataCallback: function computeMetadataCallback() {
          return _this3._columnSizeAndPositionManager.resetCell(0);
        },
        computeMetadataCallbackProps: nextProps,
        nextCellsCount: nextProps.columnCount,
        nextCellSize: nextProps.columnWidth,
        nextScrollToIndex: nextProps.scrollToColumn,
        scrollToIndex: this.props.scrollToColumn,
        updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() {
          return _this3._updateScrollLeftForScrollToColumn(nextProps, nextState);
        }
      });
      __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils_calculateSizeAndPositionDataAndUpdateScrollOffset__["a" /* default */])({
        cellCount: this.props.rowCount,
        cellSize: this.props.rowHeight,
        computeMetadataCallback: function computeMetadataCallback() {
          return _this3._rowSizeAndPositionManager.resetCell(0);
        },
        computeMetadataCallbackProps: nextProps,
        nextCellsCount: nextProps.rowCount,
        nextCellSize: nextProps.rowHeight,
        nextScrollToIndex: nextProps.scrollToRow,
        scrollToIndex: this.props.scrollToRow,
        updateScrollOffsetForScrollToIndex: function updateScrollOffsetForScrollToIndex() {
          return _this3._updateScrollTopForScrollToRow(nextProps, nextState);
        }
      });

this._calculateChildrenToRender(nextProps, nextState);
    }
  }, {
    key: 'render',
    value: function render() {
      var _this4 = this;

var _props4 = this.props;
      var autoContainerWidth = _props4.autoContainerWidth;
      var autoHeight = _props4.autoHeight;
      var className = _props4.className;
      var height = _props4.height;
      var noContentRenderer = _props4.noContentRenderer;
      var style = _props4.style;
      var tabIndex = _props4.tabIndex;
      var width = _props4.width;
      var isScrolling = this.state.isScrolling;

var gridStyle = {
        boxSizing: 'border-box',
        height: autoHeight ? 'auto' : height,
        position: 'relative',
        width: width,
        WebkitOverflowScrolling: 'touch',
        willChange: 'transform'
      };

var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize();
      var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize();

// Also explicitly init styles to 'auto' if scrollbars are required.
      // This works around an obscure edge case where external CSS styles have not yet been loaded,
      // But an initial scroll index of offset is set as an external prop.
      // Without this style, Grid would render the correct range of cells but would NOT update its internal offset.
      // This was originally reported via clauderic/react-infinite-calendar/issues/23
      gridStyle.overflowX = totalColumnsWidth + verticalScrollBarSize <= width ? 'hidden' : 'auto';
      gridStyle.overflowY = totalRowsHeight + horizontalScrollBarSize <= height ? 'hidden' : 'auto';

var childrenToDisplay = this._childrenToDisplay;

var showNoContentRenderer = childrenToDisplay.length === 0 && height > 0 && width > 0;

return __WEBPACK_IMPORTED_MODULE_6_react___default.a.createElement(
        'div',
        {
          ref: function ref(_ref2) {
            _this4._scrollingContainer = _ref2;
          },
          'aria-label': this.props['aria-label'],
          className: __WEBPACK_IMPORTED_MODULE_7_classnames___default()('ReactVirtualized__Grid', className),
          onScroll: this._onScroll,
          role: 'grid',
          style: __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, gridStyle, style),
          tabIndex: tabIndex
        },
        childrenToDisplay.length > 0 && __WEBPACK_IMPORTED_MODULE_6_react___default.a.createElement(
          'div',
          {
            className: 'ReactVirtualized__Grid__innerScrollContainer',
            style: {
              width: autoContainerWidth ? 'auto' : totalColumnsWidth,
              height: totalRowsHeight,
              maxWidth: totalColumnsWidth,
              maxHeight: totalRowsHeight,
              overflow: 'hidden',
              pointerEvents: isScrolling ? 'none' : ''
            }
          },
          childrenToDisplay
        ),
        showNoContentRenderer && noContentRenderer()
      );
    }
  }, {
    key: 'shouldComponentUpdate',
    value: function shouldComponentUpdate(nextProps, nextState) {
      return __WEBPACK_IMPORTED_MODULE_13_react_addons_shallow_compare___default()(this, nextProps, nextState);
    }

/* ---------------------------- Helper methods ---------------------------- */

}, {
    key: '_calculateChildrenToRender',
    value: function _calculateChildrenToRender() {
      var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0];
      var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1];
      var cellRenderer = props.cellRenderer;
      var cellRangeRenderer = props.cellRangeRenderer;
      var columnCount = props.columnCount;
      var height = props.height;
      var overscanColumnCount = props.overscanColumnCount;
      var overscanRowCount = props.overscanRowCount;
      var rowCount = props.rowCount;
      var width = props.width;
      var isScrolling = state.isScrolling;
      var scrollDirectionHorizontal = state.scrollDirectionHorizontal;
      var scrollDirectionVertical = state.scrollDirectionVertical;
      var scrollLeft = state.scrollLeft;
      var scrollTop = state.scrollTop;

this._childrenToDisplay = [];

// Render only enough columns and rows to cover the visible area of the grid.
      if (height > 0 && width > 0) {
        var visibleColumnIndices = this._columnSizeAndPositionManager.getVisibleCellRange({
          containerSize: width,
          offset: scrollLeft
        });
        var visibleRowIndices = this._rowSizeAndPositionManager.getVisibleCellRange({
          containerSize: height,
          offset: scrollTop
        });

var horizontalOffsetAdjustment = this._columnSizeAndPositionManager.getOffsetAdjustment({
          containerSize: width,
          offset: scrollLeft
        });
        var verticalOffsetAdjustment = this._rowSizeAndPositionManager.getOffsetAdjustment({
          containerSize: height,
          offset: scrollTop
        });

// Store for _invokeOnGridRenderedHelper()
        this._renderedColumnStartIndex = visibleColumnIndices.start;
        this._renderedColumnStopIndex = visibleColumnIndices.stop;
        this._renderedRowStartIndex = visibleRowIndices.start;
        this._renderedRowStopIndex = visibleRowIndices.stop;

var overscanColumnIndices = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["b" /* default */])({
          cellCount: columnCount,
          overscanCellsCount: overscanColumnCount,
          scrollDirection: scrollDirectionHorizontal,
          startIndex: this._renderedColumnStartIndex,
          stopIndex: this._renderedColumnStopIndex
        });

var overscanRowIndices = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["b" /* default */])({
          cellCount: rowCount,
          overscanCellsCount: overscanRowCount,
          scrollDirection: scrollDirectionVertical,
          startIndex: this._renderedRowStartIndex,
          stopIndex: this._renderedRowStopIndex
        });

// Store for _invokeOnGridRenderedHelper()
        this._columnStartIndex = overscanColumnIndices.overscanStartIndex;
        this._columnStopIndex = overscanColumnIndices.overscanStopIndex;
        this._rowStartIndex = overscanRowIndices.overscanStartIndex;
        this._rowStopIndex = overscanRowIndices.overscanStopIndex;

this._childrenToDisplay = cellRangeRenderer({
          cellCache: this._cellCache,
          cellRenderer: cellRenderer,
          columnSizeAndPositionManager: this._columnSizeAndPositionManager,
          columnStartIndex: this._columnStartIndex,
          columnStopIndex: this._columnStopIndex,
          horizontalOffsetAdjustment: horizontalOffsetAdjustment,
          isScrolling: isScrolling,
          rowSizeAndPositionManager: this._rowSizeAndPositionManager,
          rowStartIndex: this._rowStartIndex,
          rowStopIndex: this._rowStopIndex,
          scrollLeft: scrollLeft,
          scrollTop: scrollTop,
          verticalOffsetAdjustment: verticalOffsetAdjustment
        });
      }
    }

/**
     * Sets an :isScrolling flag for a small window of time.
     * This flag is used to disable pointer events on the scrollable portion of the Grid.
     * This prevents jerky/stuttery mouse-wheel scrolling.
     */

}, {
    key: '_enablePointerEventsAfterDelay',
    value: function _enablePointerEventsAfterDelay() {
      var scrollingResetTimeInterval = this.props.scrollingResetTimeInterval;

if (this._disablePointerEventsTimeoutId) {
        clearTimeout(this._disablePointerEventsTimeoutId);
      }

this._disablePointerEventsTimeoutId = setTimeout(this._enablePointerEventsAfterDelayCallback, scrollingResetTimeInterval);
    }
  }, {
    key: '_enablePointerEventsAfterDelayCallback',
    value: function _enablePointerEventsAfterDelayCallback() {
      this._disablePointerEventsTimeoutId = null;

// Throw away cell cache once scrolling is complete
      this._cellCache = {};

this.setState({
        isScrolling: false,
        scrollDirectionHorizontal: __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["a" /* SCROLL_DIRECTION_FIXED */],
        scrollDirectionVertical: __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["a" /* SCROLL_DIRECTION_FIXED */]
      });
    }
  }, {
    key: '_getEstimatedColumnSize',
    value: function _getEstimatedColumnSize(props) {
      return typeof props.columnWidth === 'number' ? props.columnWidth : props.estimatedColumnSize;
    }
  }, {
    key: '_getEstimatedRowSize',
    value: function _getEstimatedRowSize(props) {
      return typeof props.rowHeight === 'number' ? props.rowHeight : props.estimatedRowSize;
    }
  }, {
    key: '_invokeOnGridRenderedHelper',
    value: function _invokeOnGridRenderedHelper() {
      var onSectionRendered = this.props.onSectionRendered;

this._onGridRenderedMemoizer({
        callback: onSectionRendered,
        indices: {
          columnOverscanStartIndex: this._columnStartIndex,
          columnOverscanStopIndex: this._columnStopIndex,
          columnStartIndex: this._renderedColumnStartIndex,
          columnStopIndex: this._renderedColumnStopIndex,
          rowOverscanStartIndex: this._rowStartIndex,
          rowOverscanStopIndex: this._rowStopIndex,
          rowStartIndex: this._renderedRowStartIndex,
          rowStopIndex: this._renderedRowStopIndex
        }
      });
    }
  }, {
    key: '_invokeOnScrollMemoizer',
    value: function _invokeOnScrollMemoizer(_ref3) {
      var _this5 = this;

var scrollLeft = _ref3.scrollLeft;
      var scrollTop = _ref3.scrollTop;
      var totalColumnsWidth = _ref3.totalColumnsWidth;
      var totalRowsHeight = _ref3.totalRowsHeight;

this._onScrollMemoizer({
        callback: function callback(_ref4) {
          var scrollLeft = _ref4.scrollLeft;
          var scrollTop = _ref4.scrollTop;
          var _props5 = _this5.props;
          var height = _props5.height;
          var onScroll = _props5.onScroll;
          var width = _props5.width;

onScroll({
            clientHeight: height,
            clientWidth: width,
            scrollHeight: totalRowsHeight,
            scrollLeft: scrollLeft,
            scrollTop: scrollTop,
            scrollWidth: totalColumnsWidth
          });
        },
        indices: {
          scrollLeft: scrollLeft,
          scrollTop: scrollTop
        }
      });
    }
  }, {
    key: '_setScrollPosition',
    value: function _setScrollPosition(_ref5) {
      var scrollLeft = _ref5.scrollLeft;
      var scrollTop = _ref5.scrollTop;

var newState = {
        scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED
      };

if (scrollLeft >= 0) {
        newState.scrollLeft = scrollLeft;
      }

if (scrollTop >= 0) {
        newState.scrollTop = scrollTop;
      }

if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) {
        this.setState(newState);
      }
    }
  }, {
    key: '_wrapPropertyGetter',
    value: function _wrapPropertyGetter(value) {
      return value instanceof Function ? value : function () {
        return value;
      };
    }
  }, {
    key: '_wrapSizeGetter',
    value: function _wrapSizeGetter(size) {
      return this._wrapPropertyGetter(size);
    }
  }, {
    key: '_updateScrollLeftForScrollToColumn',
    value: function _updateScrollLeftForScrollToColumn() {
      var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0];
      var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1];
      var columnCount = props.columnCount;
      var scrollToAlignment = props.scrollToAlignment;
      var scrollToColumn = props.scrollToColumn;
      var width = props.width;
      var scrollLeft = state.scrollLeft;

if (scrollToColumn >= 0 && columnCount > 0) {
        var targetIndex = Math.max(0, Math.min(columnCount - 1, scrollToColumn));

var calculatedScrollLeft = this._columnSizeAndPositionManager.getUpdatedOffsetForIndex({
          align: scrollToAlignment,
          containerSize: width,
          currentOffset: scrollLeft,
          targetIndex: targetIndex
        });

if (scrollLeft !== calculatedScrollLeft) {
          this._setScrollPosition({
            scrollLeft: calculatedScrollLeft
          });
        }
      }
    }
  }, {
    key: '_updateScrollTopForScrollToRow',
    value: function _updateScrollTopForScrollToRow() {
      var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0];
      var state = arguments.length <= 1 || arguments[1] === undefined ? this.state : arguments[1];
      var height = props.height;
      var rowCount = props.rowCount;
      var scrollToAlignment = props.scrollToAlignment;
      var scrollToRow = props.scrollToRow;
      var scrollTop = state.scrollTop;

if (scrollToRow >= 0 && rowCount > 0) {
        var targetIndex = Math.max(0, Math.min(rowCount - 1, scrollToRow));

var calculatedScrollTop = this._rowSizeAndPositionManager.getUpdatedOffsetForIndex({
          align: scrollToAlignment,
          containerSize: height,
          currentOffset: scrollTop,
          targetIndex: targetIndex
        });

if (scrollTop !== calculatedScrollTop) {
          this._setScrollPosition({
            scrollTop: calculatedScrollTop
          });
        }
      }
    }
  }, {
    key: '_onScroll',
    value: function _onScroll(event) {
      // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.
      // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.
      // See issue #404 for more information.
      if (event.target !== this._scrollingContainer) {
        return;
      }

// Prevent pointer events from interrupting a smooth scroll
      this._enablePointerEventsAfterDelay();

// When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,
      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.
      // This causes a series of rapid renders that is slow for long lists.
      // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height.
      var _props6 = this.props;
      var height = _props6.height;
      var width = _props6.width;

var scrollbarSize = this._scrollbarSize;
      var totalRowsHeight = this._rowSizeAndPositionManager.getTotalSize();
      var totalColumnsWidth = this._columnSizeAndPositionManager.getTotalSize();
      var scrollLeft = Math.min(Math.max(0, totalColumnsWidth - width + scrollbarSize), event.target.scrollLeft);
      var scrollTop = Math.min(Math.max(0, totalRowsHeight - height + scrollbarSize), event.target.scrollTop);

// Certain devices (like Apple touchpad) rapid-fire duplicate events.
      // Don't force a re-render if this is the case.
      // The mouse may move faster then the animation frame does.
      // Use requestAnimationFrame to avoid over-updating.
      if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) {
        // Track scrolling direction so we can more efficiently overscan rows to reduce empty space around the edges while scrolling.
        var scrollDirectionVertical = scrollTop > this.state.scrollTop ? __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["c" /* SCROLL_DIRECTION_FORWARD */] : __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["d" /* SCROLL_DIRECTION_BACKWARD */];
        var scrollDirectionHorizontal = scrollLeft > this.state.scrollLeft ? __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["c" /* SCROLL_DIRECTION_FORWARD */] : __WEBPACK_IMPORTED_MODULE_11__utils_getOverscanIndices__["d" /* SCROLL_DIRECTION_BACKWARD */];

this.setState({
          isScrolling: true,
          scrollDirectionHorizontal: scrollDirectionHorizontal,
          scrollDirectionVertical: scrollDirectionVertical,
          scrollLeft: scrollLeft,
          scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.OBSERVED,
          scrollTop: scrollTop
        });
      }

this._invokeOnScrollMemoizer({ scrollLeft: scrollLeft, scrollTop: scrollTop, totalColumnsWidth: totalColumnsWidth, totalRowsHeight: totalRowsHeight });
    }
  }]);

return Grid;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

Grid.propTypes = {
  'aria-label': __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].string,

/**
   * Set the width of the inner scrollable container to 'auto'.
   * This is useful for single-column Grids to ensure that the column doesn't extend below a vertical scrollbar.
   */
  autoContainerWidth: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].bool,

/**
   * Removes fixed height from the scrollingContainer so that the total height
   * of rows can stretch the window. Intended for use with WindowScroller
   */
  autoHeight: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].bool,

/**
   * Responsible for rendering a cell given an row and column index.
   * Should implement the following interface: ({ columnIndex: number, rowIndex: number }): PropTypes.node
   */
  cellRenderer: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].func.isRequired,

/**
   * Responsible for rendering a group of cells given their index ranges.
   * Should implement the following interface: ({
   *   cellCache: Map,
   *   cellRenderer: Function,
   *   columnSizeAndPositionManager: CellSizeAndPositionManager,
   *   columnStartIndex: number,
   *   columnStopIndex: number,
   *   isScrolling: boolean,
   *   rowSizeAndPositionManager: CellSizeAndPositionManager,
   *   rowStartIndex: number,
   *   rowStopIndex: number,
   *   scrollLeft: number,
   *   scrollTop: number
   * }): Array<PropTypes.node>
   */
  cellRangeRenderer: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].func.isRequired,

/**
   * Optional custom CSS class name to attach to root Grid element.
   */
  className: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].string,

/**
   * Number of columns in grid.
   */
  columnCount: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number.isRequired,

/**
   * Either a fixed column width (number) or a function that returns the width of a column given its index.
   * Should implement the following interface: (index: number): number
   */
  columnWidth: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].oneOfType([__WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number, __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].func]).isRequired,

/**
   * Used to estimate the total width of a Grid before all of its columns have actually been measured.
   * The estimated total width is adjusted as columns are rendered.
   */
  estimatedColumnSize: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number.isRequired,

/**
   * Used to estimate the total height of a Grid before all of its rows have actually been measured.
   * The estimated total height is adjusted as rows are rendered.
   */
  estimatedRowSize: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number.isRequired,

/**
   * Height of Grid; this property determines the number of visible (vs virtualized) rows.
   */
  height: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number.isRequired,

/**
   * Optional renderer to be used in place of rows when either :rowCount or :columnCount is 0.
   */
  noContentRenderer: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].func.isRequired,

/**
   * Callback invoked whenever the scroll offset changes within the inner scrollable region.
   * This callback can be used to sync scrolling between lists, tables, or grids.
   * ({ clientHeight, clientWidth, scrollHeight, scrollLeft, scrollTop, scrollWidth }): void
   */
  onScroll: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].func.isRequired,

/**
   * Callback invoked with information about the section of the Grid that was just rendered.
   * ({ columnStartIndex, columnStopIndex, rowStartIndex, rowStopIndex }): void
   */
  onSectionRendered: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].func.isRequired,

/**
   * Number of columns to render before/after the visible section of the grid.
   * These columns can help for smoother scrolling on touch devices or browsers that send scroll events infrequently.
   */
  overscanColumnCount: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number.isRequired,

/**
   * Number of rows to render above/below the visible section of the grid.
   * These rows can help for smoother scrolling on touch devices or browsers that send scroll events infrequently.
   */
  overscanRowCount: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number.isRequired,

/**
   * Either a fixed row height (number) or a function that returns the height of a row given its index.
   * Should implement the following interface: ({ index: number }): number
   */
  rowHeight: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].oneOfType([__WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number, __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].func]).isRequired,

/**
   * Number of rows in grid.
   */
  rowCount: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number.isRequired,

/** Wait this amount of time after the last scroll event before resetting Grid `pointer-events`. */
  scrollingResetTimeInterval: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number,

/** Horizontal offset. */
  scrollLeft: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number,

/**
   * Controls scroll-to-cell behavior of the Grid.
   * The default ("auto") scrolls the least amount possible to ensure that the specified cell is fully visible.
   * Use "start" to align cells to the top/left of the Grid and "end" to align bottom/right.
   */
  scrollToAlignment: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].oneOf(['auto', 'end', 'start', 'center']).isRequired,

/**
   * Column index to ensure visible (by forcefully scrolling if necessary)
   */
  scrollToColumn: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number,

/** Vertical offset. */
  scrollTop: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number,

/**
   * Row index to ensure visible (by forcefully scrolling if necessary)
   */
  scrollToRow: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number,

/** Optional inline style */
  style: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].object,

/** Tab index for focus */
  tabIndex: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number,

/**
   * Width of Grid; this property determines the number of visible (vs virtualized) columns.
   */
  width: __WEBPACK_IMPORTED_MODULE_6_react__["PropTypes"].number.isRequired
};
Grid.defaultProps = {
  'aria-label': 'grid',
  cellRangeRenderer: __WEBPACK_IMPORTED_MODULE_15__defaultCellRangeRenderer__["a" /* default */],
  estimatedColumnSize: 100,
  estimatedRowSize: 30,
  noContentRenderer: function noContentRenderer() {
    return null;
  },
  onScroll: function onScroll() {
    return null;
  },
  onSectionRendered: function onSectionRendered() {
    return null;
  },
  overscanColumnCount: 0,
  overscanRowCount: 10,
  scrollingResetTimeInterval: DEFAULT_SCROLLING_RESET_TIME_INTERVAL,
  scrollToAlignment: 'auto',
  style: {},
  tabIndex: 0
};
/* harmony default export */ __webpack_exports__["a"] = (Grid);

/***/ }),
/* 518 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = defaultCellRangeRenderer;

var renderedCells = [];

for (var rowIndex = rowStartIndex; rowIndex <= rowStopIndex; rowIndex++) {
    var rowDatum = rowSizeAndPositionManager.getSizeAndPositionOfCell(rowIndex);

var cellRendererParams = {
        columnIndex: columnIndex,
        isScrolling: isScrolling,
        key: key,
        rowIndex: rowIndex,
        style: style
      };

var renderedCell = void 0;

if (renderedCell == null || renderedCell === false) {
        continue;
      }

renderedCells.push(renderedCell);
    }
  }

return renderedCells;
}

/***/ }),
/* 519 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * CSS properties which accept numbers but are not in units of "px".
 */

var isUnitlessNumber = {
  animationIterationCount: true,
  borderImageOutset: true,
  borderImageSlice: true,
  borderImageWidth: true,
  boxFlex: true,
  boxFlexGroup: true,
  boxOrdinalGroup: true,
  columnCount: true,
  flex: true,
  flexGrow: true,
  flexPositive: true,
  flexShrink: true,
  flexNegative: true,
  flexOrder: true,
  gridRow: true,
  gridColumn: true,
  fontWeight: true,
  lineClamp: true,
  lineHeight: true,
  opacity: true,
  order: true,
  orphans: true,
  tabSize: true,
  widows: true,
  zIndex: true,
  zoom: true,

// SVG-related properties
  fillOpacity: true,
  floodOpacity: true,
  stopOpacity: true,
  strokeDasharray: true,
  strokeDashoffset: true,
  strokeMiterlimit: true,
  strokeOpacity: true,
  strokeWidth: true
};

/**
 * @param {string} prefix vendor-specific prefix, eg: Webkit
 * @param {string} key style name, eg: transitionDuration
 * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
 * WebkitTransitionDuration
 */
function prefixKey(prefix, key) {
  return prefix + key.charAt(0).toUpperCase() + key.substring(1);
}

/**
 * Support style names that may come passed in prefixed by adding permutations
 * of vendor prefixes.
 */
var prefixes = ['Webkit', 'ms', 'Moz', 'O'];

// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
// infinite loop, because it iterates over the newly added props too.
Object.keys(isUnitlessNumber).forEach(function (prop) {
  prefixes.forEach(function (prefix) {
    isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
  });
});

/**
 * Most style properties can be unset by doing .style[prop] = '' but IE8
 * doesn't like doing that with shorthand properties so for the properties that
 * IE8 breaks on, which are listed here, we instead unset each of the
 * individual properties. See http://bugs.jquery.com/ticket/12385.
 * The 4-value 'clock' properties like margin, padding, border-width seem to
 * behave without any problems. Curiously, list-style works too without any
 * special prodding.
 */
var shorthandPropertyExpansions = {
  background: {
    backgroundAttachment: true,
    backgroundColor: true,
    backgroundImage: true,
    backgroundPositionX: true,
    backgroundPositionY: true,
    backgroundRepeat: true
  },
  backgroundPosition: {
    backgroundPositionX: true,
    backgroundPositionY: true
  },
  border: {
    borderWidth: true,
    borderStyle: true,
    borderColor: true
  },
  borderBottom: {
    borderBottomWidth: true,
    borderBottomStyle: true,
    borderBottomColor: true
  },
  borderLeft: {
    borderLeftWidth: true,
    borderLeftStyle: true,
    borderLeftColor: true
  },
  borderRight: {
    borderRightWidth: true,
    borderRightStyle: true,
    borderRightColor: true
  },
  borderTop: {
    borderTopWidth: true,
    borderTopStyle: true,
    borderTopColor: true
  },
  font: {
    fontStyle: true,
    fontVariant: true,
    fontWeight: true,
    fontSize: true,
    lineHeight: true,
    fontFamily: true
  },
  outline: {
    outlineWidth: true,
    outlineStyle: true,
    outlineColor: true
  }
};

var CSSProperty = {
  isUnitlessNumber: isUnitlessNumber,
  shorthandPropertyExpansions: shorthandPropertyExpansions
};

module.exports = CSSProperty;

/***/ }),
/* 520 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21),
    _assign = __webpack_require__(24);

var PooledClass = __webpack_require__(76);

var invariant = __webpack_require__(19);

/**
 * A specialized pseudo-event module to help keep track of components waiting to
 * be notified when their DOM representations are available for use.
 *
 * This implements `PooledClass`, so you should never need to instantiate this.
 * Instead, use `CallbackQueue.getPooled()`.
 *
 * @class ReactMountReady
 * @implements PooledClass
 * @internal
 */
function CallbackQueue() {
  this._callbacks = null;
  this._contexts = null;
}

_assign(CallbackQueue.prototype, {

/**
   * Enqueues a callback to be invoked when `notifyAll` is invoked.
   *
   * @param {function} callback Invoked when `notifyAll` is invoked.
   * @param {?object} context Context to call `callback` with.
   * @internal
   */
  enqueue: function (callback, context) {
    this._callbacks = this._callbacks || [];
    this._contexts = this._contexts || [];
    this._callbacks.push(callback);
    this._contexts.push(context);
  },

/**
   * Invokes all enqueued callbacks and clears the queue. This is invoked after
   * the DOM representation of a component has been created or updated.
   *
   * @internal
   */
  notifyAll: function () {
    var callbacks = this._callbacks;
    var contexts = this._contexts;
    if (callbacks) {
      !(callbacks.length === contexts.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : _prodInvariant('24') : void 0;
      this._callbacks = null;
      this._contexts = null;
      for (var i = 0; i < callbacks.length; i++) {
        callbacks[i].call(contexts[i]);
      }
      callbacks.length = 0;
      contexts.length = 0;
    }
  },

checkpoint: function () {
    return this._callbacks ? this._callbacks.length : 0;
  },

rollback: function (len) {
    if (this._callbacks) {
      this._callbacks.length = len;
      this._contexts.length = len;
    }
  },

/**
   * Resets the internal queue.
   *
   * @internal
   */
  reset: function () {
    this._callbacks = null;
    this._contexts = null;
  },

/**
   * `PooledClass` looks for this.
   */
  destructor: function () {
    this.reset();
  }

});

PooledClass.addPoolingTo(CallbackQueue);

module.exports = CallbackQueue;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 521 */
/***/ (function(module, exports, __webpack_require__) {

var DOMProperty = __webpack_require__(90);
var ReactDOMComponentTree = __webpack_require__(28);
var ReactInstrumentation = __webpack_require__(41);

var quoteAttributeValueForBrowser = __webpack_require__(1425);
var warning = __webpack_require__(18);

var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + DOMProperty.ATTRIBUTE_NAME_START_CHAR + '][' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$');
var illegalAttributeNameCache = {};
var validatedAttributeNameCache = {};

function shouldIgnoreValue(propertyInfo, value) {
  return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false;
}

/**
 * Operations for dealing with DOM properties.
 */
var DOMPropertyOperations = {

/**
   * Creates markup for the ID property.
   *
   * @param {string} id Unescaped ID.
   * @return {string} Markup string.
   */
  createMarkupForID: function (id) {
    return DOMProperty.ID_ATTRIBUTE_NAME + '=' + quoteAttributeValueForBrowser(id);
  },

setAttributeForID: function (node, id) {
    node.setAttribute(DOMProperty.ID_ATTRIBUTE_NAME, id);
  },

createMarkupForRoot: function () {
    return DOMProperty.ROOT_ATTRIBUTE_NAME + '=""';
  },

setAttributeForRoot: function (node) {
    node.setAttribute(DOMProperty.ROOT_ATTRIBUTE_NAME, '');
  },

/**
   * Creates markup for a property.
   *
   * @param {string} name
   * @param {*} value
   * @return {?string} Markup string, or null if the property was invalid.
   */
  createMarkupForProperty: function (name, value) {
    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
    if (propertyInfo) {
      if (shouldIgnoreValue(propertyInfo, value)) {
        return '';
      }
      var attributeName = propertyInfo.attributeName;
      if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
        return attributeName + '=""';
      }
      return attributeName + '=' + quoteAttributeValueForBrowser(value);
    } else if (DOMProperty.isCustomAttribute(name)) {
      if (value == null) {
        return '';
      }
      return name + '=' + quoteAttributeValueForBrowser(value);
    }
    return null;
  },

/**
   * Creates markup for a custom property.
   *
   * @param {string} name
   * @param {*} value
   * @return {string} Markup string, or empty string if the property was invalid.
   */
  createMarkupForCustomAttribute: function (name, value) {
    if (!isAttributeNameSafe(name) || value == null) {
      return '';
    }
    return name + '=' + quoteAttributeValueForBrowser(value);
  },

/**
   * Sets the value for a property on a node.
   *
   * @param {DOMElement} node
   * @param {string} name
   * @param {*} value
   */
  setValueForProperty: function (node, name, value) {
    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
    if (propertyInfo) {
      var mutationMethod = propertyInfo.mutationMethod;
      if (mutationMethod) {
        mutationMethod(node, value);
      } else if (shouldIgnoreValue(propertyInfo, value)) {
        this.deleteValueForProperty(node, name);
        return;
      } else if (propertyInfo.mustUseProperty) {
        // Contrary to `setAttribute`, object properties are properly
        // `toString`ed by IE8/9.
        node[propertyInfo.propertyName] = value;
      } else {
        var attributeName = propertyInfo.attributeName;
        var namespace = propertyInfo.attributeNamespace;
        // `setAttribute` with objects becomes only `[object]` in IE8/9,
        // ('' + value) makes it output the correct toString()-value.
        if (namespace) {
          node.setAttributeNS(namespace, attributeName, '' + value);
        } else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
          node.setAttribute(attributeName, '');
        } else {
          node.setAttribute(attributeName, '' + value);
        }
      }
    } else if (DOMProperty.isCustomAttribute(name)) {
      DOMPropertyOperations.setValueForAttribute(node, name, value);
      return;
    }

if (process.env.NODE_ENV !== 'production') {
      var payload = {};
      payload[name] = value;
      ReactInstrumentation.debugTool.onHostOperation(ReactDOMComponentTree.getInstanceFromNode(node)._debugID, 'update attribute', payload);
    }
  },

setValueForAttribute: function (node, name, value) {
    if (!isAttributeNameSafe(name)) {
      return;
    }
    if (value == null) {
      node.removeAttribute(name);
    } else {
      node.setAttribute(name, '' + value);
    }

/**
   * Deletes an attributes from a node.
   *
   * @param {DOMElement} node
   * @param {string} name
   */
  deleteValueForAttribute: function (node, name) {
    node.removeAttribute(name);
    if (process.env.NODE_ENV !== 'production') {
      ReactInstrumentation.debugTool.onHostOperation(ReactDOMComponentTree.getInstanceFromNode(node)._debugID, 'remove attribute', name);
    }
  },

/**
   * Deletes the value for a property on a node.
   *
   * @param {DOMElement} node
   * @param {string} name
   */
  deleteValueForProperty: function (node, name) {
    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
    if (propertyInfo) {
      var mutationMethod = propertyInfo.mutationMethod;
      if (mutationMethod) {
        mutationMethod(node, undefined);
      } else if (propertyInfo.mustUseProperty) {
        var propName = propertyInfo.propertyName;
        if (propertyInfo.hasBooleanValue) {
          node[propName] = false;
        } else {
          node[propName] = '';
        }
      } else {
        node.removeAttribute(propertyInfo.attributeName);
      }
    } else if (DOMProperty.isCustomAttribute(name)) {
      node.removeAttribute(name);
    }

if (process.env.NODE_ENV !== 'production') {
      ReactInstrumentation.debugTool.onHostOperation(ReactDOMComponentTree.getInstanceFromNode(node)._debugID, 'remove attribute', name);
    }
  }

};

module.exports = DOMPropertyOperations;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 522 */
/***/ (function(module, exports, __webpack_require__) {

var PooledClass = __webpack_require__(76);
var ReactElement = __webpack_require__(51);

var emptyFunction = __webpack_require__(44);
var traverseAllChildren = __webpack_require__(338);

var twoArgumentPooler = PooledClass.twoArgumentPooler;
var fourArgumentPooler = PooledClass.fourArgumentPooler;

var userProvidedKeyEscapeRegex = /\/+/g;
function escapeUserProvidedKey(text) {
  return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
}

/**
 * PooledClass representing the bookkeeping associated with performing a child
 * traversal. Allows avoiding binding callbacks.
 *
 * @constructor ForEachBookKeeping
 * @param {!function} forEachFunction Function to perform traversal with.
 * @param {?*} forEachContext Context to perform context with.
 */
function ForEachBookKeeping(forEachFunction, forEachContext) {
  this.func = forEachFunction;
  this.context = forEachContext;
  this.count = 0;
}
ForEachBookKeeping.prototype.destructor = function () {
  this.func = null;
  this.context = null;
  this.count = 0;
};
PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);

function forEachSingleChild(bookKeeping, child, name) {
  var func = bookKeeping.func;
  var context = bookKeeping.context;

func.call(context, child, bookKeeping.count++);
}

/**
 * Iterates through children that are typically specified as `props.children`.
 *
 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.foreach
 *
 * The provided forEachFunc(child, index) will be called for each
 * leaf child.
 *
 * @param {?*} children Children tree container.
 * @param {function(*, int)} forEachFunc
 * @param {*} forEachContext Context for forEachContext.
 */
function forEachChildren(children, forEachFunc, forEachContext) {
  if (children == null) {
    return children;
  }
  var traverseContext = ForEachBookKeeping.getPooled(forEachFunc, forEachContext);
  traverseAllChildren(children, forEachSingleChild, traverseContext);
  ForEachBookKeeping.release(traverseContext);
}

/**
 * PooledClass representing the bookkeeping associated with performing a child
 * mapping. Allows avoiding binding callbacks.
 *
 * @constructor MapBookKeeping
 * @param {!*} mapResult Object containing the ordered map of results.
 * @param {!function} mapFunction Function to perform mapping with.
 * @param {?*} mapContext Context to perform mapping with.
 */
function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) {
  this.result = mapResult;
  this.keyPrefix = keyPrefix;
  this.func = mapFunction;
  this.context = mapContext;
  this.count = 0;
}
MapBookKeeping.prototype.destructor = function () {
  this.result = null;
  this.keyPrefix = null;
  this.func = null;
  this.context = null;
  this.count = 0;
};
PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler);

function mapSingleChildIntoContext(bookKeeping, child, childKey) {
  var result = bookKeeping.result;
  var keyPrefix = bookKeeping.keyPrefix;
  var func = bookKeeping.func;
  var context = bookKeeping.context;

function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
  var escapedPrefix = '';
  if (prefix != null) {
    escapedPrefix = escapeUserProvidedKey(prefix) + '/';
  }
  var traverseContext = MapBookKeeping.getPooled(array, escapedPrefix, func, context);
  traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
  MapBookKeeping.release(traverseContext);
}

/**
 * Maps children that are typically specified as `props.children`.
 *
 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.map
 *
 * The provided mapFunction(child, key, index) will be called for each
 * leaf child.
 *
 * @param {?*} children Children tree container.
 * @param {function(*, int)} func The map function.
 * @param {*} context Context for mapFunction.
 * @return {object} Object containing the ordered map of results.
 */
function mapChildren(children, func, context) {
  if (children == null) {
    return children;
  }
  var result = [];
  mapIntoWithKeyPrefixInternal(children, result, null, func, context);
  return result;
}

function forEachSingleChildDummy(traverseContext, child, name) {
  return null;
}

/**
 * Count the number of children that are typically specified as
 * `props.children`.
 *
 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.count
 *
 * @param {?*} children Children tree container.
 * @return {number} The number of children.
 */
function countChildren(children, context) {
  return traverseAllChildren(children, forEachSingleChildDummy, null);
}

/**
 * Flatten a children object (typically specified as `props.children`) and
 * return an array with appropriately re-keyed children.
 *
 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.toarray
 */
function toArray(children) {
  var result = [];
  mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);
  return result;
}

var ReactChildren = {
  forEach: forEachChildren,
  map: mapChildren,
  mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal,
  count: countChildren,
  toArray: toArray
};

module.exports = ReactChildren;

/***/ }),
/* 523 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21),
    _assign = __webpack_require__(24);

var ReactComponent = __webpack_require__(322);
var ReactElement = __webpack_require__(51);
var ReactPropTypeLocations = __webpack_require__(195);
var ReactPropTypeLocationNames = __webpack_require__(327);
var ReactNoopUpdateQueue = __webpack_require__(326);

var emptyObject = __webpack_require__(131);
var invariant = __webpack_require__(19);
var keyMirror = __webpack_require__(167);
var keyOf = __webpack_require__(72);
var warning = __webpack_require__(18);

var MIXINS_KEY = keyOf({ mixins: null });

/**
 * Policies that describe methods in `ReactClassInterface`.
 */
var SpecPolicy = keyMirror({
  /**
   * These methods may be defined only once by the class specification or mixin.
   */
  DEFINE_ONCE: null,
  /**
   * These methods may be defined by both the class specification and mixins.
   * Subsequent definitions will be chained. These methods must return void.
   */
  DEFINE_MANY: null,
  /**
   * These methods are overriding the base class.
   */
  OVERRIDE_BASE: null,
  /**
   * These methods are similar to DEFINE_MANY, except we assume they return
   * objects. We try to merge the keys of the return values of all the mixed in
   * functions. If there is a key conflict we throw.
   */
  DEFINE_MANY_MERGED: null
});

var injectedMixins = [];

/**
 * Composite components are higher-level components that compose other composite
 * or host components.
 *
 * To create a new type of `ReactClass`, pass a specification of
 * your new class to `React.createClass`. The only requirement of your class
 * specification is that you implement a `render` method.
 *
 *   var MyComponent = React.createClass({
 *     render: function() {
 *       return <div>Hello World</div>;
 *     }
 *   });
 *
 * The class specification supports a specific protocol of methods that have
 * special meaning (e.g. `render`). See `ReactClassInterface` for
 * more the comprehensive protocol. Any other properties and methods in the
 * class specification will be available on the prototype.
 *
 * @interface ReactClassInterface
 * @internal
 */
var ReactClassInterface = {

/**
   * An array of Mixin objects to include when defining your component.
   *
   * @type {array}
   * @optional
   */
  mixins: SpecPolicy.DEFINE_MANY,

/**
   * An object containing properties and methods that should be defined on
   * the component's constructor instead of its prototype (static methods).
   *
   * @type {object}
   * @optional
   */
  statics: SpecPolicy.DEFINE_MANY,

/**
   * Definition of prop types for this component.
   *
   * @type {object}
   * @optional
   */
  propTypes: SpecPolicy.DEFINE_MANY,

/**
   * Definition of context types for this component.
   *
   * @type {object}
   * @optional
   */
  contextTypes: SpecPolicy.DEFINE_MANY,

/**
   * Definition of context types this component sets for its children.
   *
   * @type {object}
   * @optional
   */
  childContextTypes: SpecPolicy.DEFINE_MANY,

// ==== Definition methods ====

/**
   * Invoked when the component is mounted. Values in the mapping will be set on
   * `this.props` if that prop is not specified (i.e. using an `in` check).
   *
   * This method is invoked before `getInitialState` and therefore cannot rely
   * on `this.state` or use `this.setState`.
   *
   * @return {object}
   * @optional
   */
  getDefaultProps: SpecPolicy.DEFINE_MANY_MERGED,

/**
   * Invoked once before the component is mounted. The return value will be used
   * as the initial value of `this.state`.
   *
   *   getInitialState: function() {
   *     return {
   *       isOn: false,
   *       fooBaz: new BazFoo()
   *     }
   *   }
   *
   * @return {object}
   * @optional
   */
  getInitialState: SpecPolicy.DEFINE_MANY_MERGED,

/**
   * @return {object}
   * @optional
   */
  getChildContext: SpecPolicy.DEFINE_MANY_MERGED,

/**
   * Uses props from `this.props` and state from `this.state` to render the
   * structure of the component.
   *
   * No guarantees are made about when or how often this method is invoked, so
   * it must not have side effects.
   *
   *   render: function() {
   *     var name = this.props.name;
   *     return <div>Hello, {name}!</div>;
   *   }
   *
   * @return {ReactComponent}
   * @nosideeffects
   * @required
   */
  render: SpecPolicy.DEFINE_ONCE,

// ==== Delegate methods ====

/**
   * Invoked when the component is initially created and about to be mounted.
   * This may have side effects, but any external subscriptions or data created
   * by this method must be cleaned up in `componentWillUnmount`.
   *
   * @optional
   */
  componentWillMount: SpecPolicy.DEFINE_MANY,

/**
   * Invoked when the component has been mounted and has a DOM representation.
   * However, there is no guarantee that the DOM node is in the document.
   *
   * Use this as an opportunity to operate on the DOM when the component has
   * been mounted (initialized and rendered) for the first time.
   *
   * @param {DOMElement} rootNode DOM element representing the component.
   * @optional
   */
  componentDidMount: SpecPolicy.DEFINE_MANY,

/**
   * Invoked before the component receives new props.
   *
   * Use this as an opportunity to react to a prop transition by updating the
   * state using `this.setState`. Current props are accessed via `this.props`.
   *
   *   componentWillReceiveProps: function(nextProps, nextContext) {
   *     this.setState({
   *       likesIncreasing: nextProps.likeCount > this.props.likeCount
   *     });
   *   }
   *
   * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop
   * transition may cause a state change, but the opposite is not true. If you
   * need it, you are probably looking for `componentWillUpdate`.
   *
   * @param {object} nextProps
   * @optional
   */
  componentWillReceiveProps: SpecPolicy.DEFINE_MANY,

/**
   * Invoked while deciding if the component should be updated as a result of
   * receiving new props, state and/or context.
   *
   * Use this as an opportunity to `return false` when you're certain that the
   * transition to the new props/state/context will not require a component
   * update.
   *
   *   shouldComponentUpdate: function(nextProps, nextState, nextContext) {
   *     return !equal(nextProps, this.props) ||
   *       !equal(nextState, this.state) ||
   *       !equal(nextContext, this.context);
   *   }
   *
   * @param {object} nextProps
   * @param {?object} nextState
   * @param {?object} nextContext
   * @return {boolean} True if the component should update.
   * @optional
   */
  shouldComponentUpdate: SpecPolicy.DEFINE_ONCE,

/**
   * Invoked when the component is about to update due to a transition from
   * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`
   * and `nextContext`.
   *
   * Use this as an opportunity to perform preparation before an update occurs.
   *
   * NOTE: You **cannot** use `this.setState()` in this method.
   *
   * @param {object} nextProps
   * @param {?object} nextState
   * @param {?object} nextContext
   * @param {ReactReconcileTransaction} transaction
   * @optional
   */
  componentWillUpdate: SpecPolicy.DEFINE_MANY,

/**
   * Invoked when the component's DOM representation has been updated.
   *
   * Use this as an opportunity to operate on the DOM when the component has
   * been updated.
   *
   * @param {object} prevProps
   * @param {?object} prevState
   * @param {?object} prevContext
   * @param {DOMElement} rootNode DOM element representing the component.
   * @optional
   */
  componentDidUpdate: SpecPolicy.DEFINE_MANY,

/**
   * Invoked when the component is about to be removed from its parent and have
   * its DOM representation destroyed.
   *
   * Use this as an opportunity to deallocate any external resources.
   *
   * NOTE: There is no `componentDidUnmount` since your component will have been
   * destroyed by that point.
   *
   * @optional
   */
  componentWillUnmount: SpecPolicy.DEFINE_MANY,

// ==== Advanced methods ====

/**
   * Updates the component's currently mounted DOM representation.
   *
   * By default, this implements React's rendering and reconciliation algorithm.
   * Sophisticated clients may wish to override this.
   *
   * @param {ReactReconcileTransaction} transaction
   * @internal
   * @overridable
   */
  updateComponent: SpecPolicy.OVERRIDE_BASE

};

/**
 * Mapping from class specification keys to special processing functions.
 *
 * Although these are declared like instance properties in the specification
 * when defining classes using `React.createClass`, they are actually static
 * and are accessible on the constructor instead of the prototype. Despite
 * being static, they must be defined outside of the "statics" key under
 * which all other static methods are defined.
 */
var RESERVED_SPEC_KEYS = {
  displayName: function (Constructor, displayName) {
    Constructor.displayName = displayName;
  },
  mixins: function (Constructor, mixins) {
    if (mixins) {
      for (var i = 0; i < mixins.length; i++) {
        mixSpecIntoComponent(Constructor, mixins[i]);
      }
    }
  },
  childContextTypes: function (Constructor, childContextTypes) {
    if (process.env.NODE_ENV !== 'production') {
      validateTypeDef(Constructor, childContextTypes, ReactPropTypeLocations.childContext);
    }
    Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, childContextTypes);
  },
  contextTypes: function (Constructor, contextTypes) {
    if (process.env.NODE_ENV !== 'production') {
      validateTypeDef(Constructor, contextTypes, ReactPropTypeLocations.context);
    }
    Constructor.contextTypes = _assign({}, Constructor.contextTypes, contextTypes);
  },
  /**
   * Special case getDefaultProps which should move into statics but requires
   * automatic merging.
   */
  getDefaultProps: function (Constructor, getDefaultProps) {
    if (Constructor.getDefaultProps) {
      Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps);
    } else {
      Constructor.getDefaultProps = getDefaultProps;
    }
  },
  propTypes: function (Constructor, propTypes) {
    if (process.env.NODE_ENV !== 'production') {
      validateTypeDef(Constructor, propTypes, ReactPropTypeLocations.prop);
    }
    Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes);
  },
  statics: function (Constructor, statics) {
    mixStaticSpecIntoComponent(Constructor, statics);
  },
  autobind: function () {} };

// noop
function validateTypeDef(Constructor, typeDef, location) {
  for (var propName in typeDef) {
    if (typeDef.hasOwnProperty(propName)) {
      // use a warning instead of an invariant so components
      // don't show up in prod but only in __DEV__
      process.env.NODE_ENV !== 'production' ? warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName) : void 0;
    }
  }
}

function validateMethodOverride(isAlreadyDefined, name) {
  var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;

// Disallow overriding of base class methods unless explicitly allowed.
  if (ReactClassMixin.hasOwnProperty(name)) {
    !(specPolicy === SpecPolicy.OVERRIDE_BASE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.', name) : _prodInvariant('73', name) : void 0;
  }

// Disallow defining methods more than once unless explicitly allowed.
  if (isAlreadyDefined) {
    !(specPolicy === SpecPolicy.DEFINE_MANY || specPolicy === SpecPolicy.DEFINE_MANY_MERGED) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('74', name) : void 0;
  }
}

/**
 * Mixin helper which handles policy validation and reserved
 * specification keys when building React classes.
 */
function mixSpecIntoComponent(Constructor, spec) {
  if (!spec) {
    if (process.env.NODE_ENV !== 'production') {
      var typeofSpec = typeof spec;
      var isMixinValid = typeofSpec === 'object' && spec !== null;

process.env.NODE_ENV !== 'production' ? warning(isMixinValid, '%s: You\'re attempting to include a mixin that is either null ' + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec) : void 0;
    }

return;
  }

!(typeof spec !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component class or function as a mixin. Instead, just use a regular object.') : _prodInvariant('75') : void 0;
  !!ReactElement.isValidElement(spec) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component as a mixin. Instead, just use a regular object.') : _prodInvariant('76') : void 0;

var proto = Constructor.prototype;
  var autoBindPairs = proto.__reactAutoBindPairs;

// By handling mixins before any other properties, we ensure the same
  // chaining order is applied to methods with DEFINE_MANY policy, whether
  // mixins are listed before or after these methods in the spec.
  if (spec.hasOwnProperty(MIXINS_KEY)) {
    RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
  }

for (var name in spec) {
    if (!spec.hasOwnProperty(name)) {
      continue;
    }

if (name === MIXINS_KEY) {
      // We have already handled mixins in a special case above.
      continue;
    }

var property = spec[name];
    var isAlreadyDefined = proto.hasOwnProperty(name);
    validateMethodOverride(isAlreadyDefined, name);

if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
      RESERVED_SPEC_KEYS[name](Constructor, property);
    } else {
      // Setup methods on prototype:
      // The following member methods should not be automatically bound:
      // 1. Expected ReactClass methods (in the "interface").
      // 2. Overridden methods (that were mixed in).
      var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
      var isFunction = typeof property === 'function';
      var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;

if (shouldAutoBind) {
        autoBindPairs.push(name, property);
        proto[name] = property;
      } else {
        if (isAlreadyDefined) {
          var specPolicy = ReactClassInterface[name];

// These cases should already be caught by validateMethodOverride.
          !(isReactClassMethod && (specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.', specPolicy, name) : _prodInvariant('77', specPolicy, name) : void 0;

// For methods which are defined more than once, call the existing
          // methods before calling the new property, merging if appropriate.
          if (specPolicy === SpecPolicy.DEFINE_MANY_MERGED) {
            proto[name] = createMergedResultFunction(proto[name], property);
          } else if (specPolicy === SpecPolicy.DEFINE_MANY) {
            proto[name] = createChainedFunction(proto[name], property);
          }
        } else {
          proto[name] = property;
          if (process.env.NODE_ENV !== 'production') {
            // Add verbose displayName to the function, which helps when looking
            // at profiling tools.
            if (typeof property === 'function' && spec.displayName) {
              proto[name].displayName = spec.displayName + '_' + name;
            }
          }
        }
      }
    }
  }
}

function mixStaticSpecIntoComponent(Constructor, statics) {
  if (!statics) {
    return;
  }
  for (var name in statics) {
    var property = statics[name];
    if (!statics.hasOwnProperty(name)) {
      continue;
    }

var isReserved = name in RESERVED_SPEC_KEYS;
    !!isReserved ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.', name) : _prodInvariant('78', name) : void 0;

var isInherited = name in Constructor;
    !!isInherited ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('79', name) : void 0;
    Constructor[name] = property;
  }
}

/**
 * Merge two objects, but throw if both contain the same key.
 *
 * @param {object} one The first object, which is mutated.
 * @param {object} two The second object
 * @return {object} one after it has been mutated to contain everything in two.
 */
function mergeIntoWithNoDuplicateKeys(one, two) {
  !(one && two && typeof one === 'object' && typeof two === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.') : _prodInvariant('80') : void 0;

for (var key in two) {
    if (two.hasOwnProperty(key)) {
      !(one[key] === undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.', key) : _prodInvariant('81', key) : void 0;
      one[key] = two[key];
    }
  }
  return one;
}

/**
 * Creates a function that invokes two functions and merges their return values.
 *
 * @param {function} one Function to invoke first.
 * @param {function} two Function to invoke second.
 * @return {function} Function that invokes the two argument functions.
 * @private
 */
function createMergedResultFunction(one, two) {
  return function mergedResult() {
    var a = one.apply(this, arguments);
    var b = two.apply(this, arguments);
    if (a == null) {
      return b;
    } else if (b == null) {
      return a;
    }
    var c = {};
    mergeIntoWithNoDuplicateKeys(c, a);
    mergeIntoWithNoDuplicateKeys(c, b);
    return c;
  };
}

/**
 * Creates a function that invokes two functions and ignores their return vales.
 *
 * @param {function} one Function to invoke first.
 * @param {function} two Function to invoke second.
 * @return {function} Function that invokes the two argument functions.
 * @private
 */
function createChainedFunction(one, two) {
  return function chainedFunction() {
    one.apply(this, arguments);
    two.apply(this, arguments);
  };
}

/**
 * Binds a method to the component.
 *
 * @param {object} component Component whose method is going to be bound.
 * @param {function} method Method to be bound.
 * @return {function} The bound method.
 */
function bindAutoBindMethod(component, method) {
  var boundMethod = method.bind(component);
  if (process.env.NODE_ENV !== 'production') {
    boundMethod.__reactBoundContext = component;
    boundMethod.__reactBoundMethod = method;
    boundMethod.__reactBoundArguments = null;
    var componentName = component.constructor.displayName;
    var _bind = boundMethod.bind;
    boundMethod.bind = function (newThis) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

// User is trying to bind() an autobound method; we effectively will
      // ignore the value of "this" that the user is trying to use, so
      // let's warn.
      if (newThis !== component && newThis !== null) {
        process.env.NODE_ENV !== 'production' ? warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName) : void 0;
      } else if (!args.length) {
        process.env.NODE_ENV !== 'production' ? warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName) : void 0;
        return boundMethod;
      }
      var reboundMethod = _bind.apply(boundMethod, arguments);
      reboundMethod.__reactBoundContext = component;
      reboundMethod.__reactBoundMethod = method;
      reboundMethod.__reactBoundArguments = args;
      return reboundMethod;
    };
  }
  return boundMethod;
}

/**
 * Binds all auto-bound methods in a component.
 *
 * @param {object} component Component whose method is going to be bound.
 */
function bindAutoBindMethods(component) {
  var pairs = component.__reactAutoBindPairs;
  for (var i = 0; i < pairs.length; i += 2) {
    var autoBindKey = pairs[i];
    var method = pairs[i + 1];
    component[autoBindKey] = bindAutoBindMethod(component, method);
  }
}

/**
 * Add more to the ReactClass base class. These are all legacy features and
 * therefore not already part of the modern ReactComponent.
 */
var ReactClassMixin = {

/**
   * TODO: This will be deprecated because state should always keep a consistent
   * type signature and the only use case for this, is to avoid that.
   */
  replaceState: function (newState, callback) {
    this.updater.enqueueReplaceState(this, newState);
    if (callback) {
      this.updater.enqueueCallback(this, callback, 'replaceState');
    }
  },

/**
   * Checks whether or not this composite component is mounted.
   * @return {boolean} True if mounted, false otherwise.
   * @protected
   * @final
   */
  isMounted: function () {
    return this.updater.isMounted(this);
  }
};

var ReactClassComponent = function () {};
_assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);

/**
 * Module for creating composite components.
 *
 * @class ReactClass
 */
var ReactClass = {

if (process.env.NODE_ENV !== 'production') {
        process.env.NODE_ENV !== 'production' ? warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory') : void 0;
      }

// Wire up auto-binding
      if (this.__reactAutoBindPairs.length) {
        bindAutoBindMethods(this);
      }

this.props = props;
      this.context = context;
      this.refs = emptyObject;
      this.updater = updater || ReactNoopUpdateQueue;

this.state = null;

// ReactClasses doesn't have constructors. Instead, they use the
      // getInitialState and componentWillMount methods for initialization.

var initialState = this.getInitialState ? this.getInitialState() : null;
      if (process.env.NODE_ENV !== 'production') {
        // We allow auto-mocks to proceed as if they're returning null.
        if (initialState === undefined && this.getInitialState._isMockFunction) {
          // This is probably bad practice. Consider warning here and
          // deprecating this convenience.
          initialState = null;
        }
      }
      !(typeof initialState === 'object' && !Array.isArray(initialState)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent') : _prodInvariant('82', Constructor.displayName || 'ReactCompositeComponent') : void 0;

this.state = initialState;
    };
    Constructor.prototype = new ReactClassComponent();
    Constructor.prototype.constructor = Constructor;
    Constructor.prototype.__reactAutoBindPairs = [];

injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));

mixSpecIntoComponent(Constructor, spec);

// Initialize the defaultProps property after all mixins have been merged.
    if (Constructor.getDefaultProps) {
      Constructor.defaultProps = Constructor.getDefaultProps();
    }

if (process.env.NODE_ENV !== 'production') {
      // This is a tag to indicate that the use of these method names is ok,
      // since it's used with createClass. If it's not, then it's likely a
      // mistake so we'll warn you to use the static property, property
      // initializer or constructor respectively.
      if (Constructor.getDefaultProps) {
        Constructor.getDefaultProps.isReactClassApproved = {};
      }
      if (Constructor.prototype.getInitialState) {
        Constructor.prototype.getInitialState.isReactClassApproved = {};
      }
    }

!Constructor.prototype.render ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createClass(...): Class specification must implement a `render` method.') : _prodInvariant('83') : void 0;

if (process.env.NODE_ENV !== 'production') {
      process.env.NODE_ENV !== 'production' ? warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component') : void 0;
      process.env.NODE_ENV !== 'production' ? warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component') : void 0;
    }

// Reduce time spent doing lookups by setting these on the prototype.
    for (var methodName in ReactClassInterface) {
      if (!Constructor.prototype[methodName]) {
        Constructor.prototype[methodName] = null;
      }
    }

return Constructor;
  },

injection: {
    injectMixin: function (mixin) {
      injectedMixins.push(mixin);
    }
  }

};

module.exports = ReactClass;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 524 */
/***/ (function(module, exports, __webpack_require__) {

var ReactDOMComponentFlags = {
  hasCachedChildNodes: 1 << 0
};

module.exports = ReactDOMComponentFlags;

/***/ }),
/* 525 */
/***/ (function(module, exports, __webpack_require__) {

var _assign = __webpack_require__(24);

var DisabledInputUtils = __webpack_require__(192);
var LinkedValueUtils = __webpack_require__(321);
var ReactDOMComponentTree = __webpack_require__(28);
var ReactUpdates = __webpack_require__(57);

var warning = __webpack_require__(18);

var didWarnValueLink = false;
var didWarnValueDefaultValue = false;

function updateOptionsIfPendingUpdateAndMounted() {
  if (this._rootNodeID && this._wrapperState.pendingUpdate) {
    this._wrapperState.pendingUpdate = false;

var props = this._currentElement.props;
    var value = LinkedValueUtils.getValue(props);

if (value != null) {
      updateOptions(this, Boolean(props.multiple), value);
    }
  }
}

function getDeclarationErrorAddendum(owner) {
  if (owner) {
    var name = owner.getName();
    if (name) {
      return ' Check the render method of `' + name + '`.';
    }
  }
  return '';
}

var valuePropNames = ['value', 'defaultValue'];

/**
 * Validation function for `value` and `defaultValue`.
 * @private
 */
function checkSelectPropTypes(inst, props) {
  var owner = inst._currentElement._owner;
  LinkedValueUtils.checkPropTypes('select', props, owner);

if (props.valueLink !== undefined && !didWarnValueLink) {
    process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `select` is deprecated; set `value` and `onChange` instead.') : void 0;
    didWarnValueLink = true;
  }

for (var i = 0; i < valuePropNames.length; i++) {
    var propName = valuePropNames[i];
    if (props[propName] == null) {
      continue;
    }
    var isArray = Array.isArray(props[propName]);
    if (props.multiple && !isArray) {
      process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
    } else if (!props.multiple && isArray) {
      process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
    }
  }
}

/**
 * @param {ReactDOMComponent} inst
 * @param {boolean} multiple
 * @param {*} propValue A stringable (with `multiple`, a list of stringables).
 * @private
 */
function updateOptions(inst, multiple, propValue) {
  var selectedValue, i;
  var options = ReactDOMComponentTree.getNodeFromInstance(inst).options;

if (multiple) {
    selectedValue = {};
    for (i = 0; i < propValue.length; i++) {
      selectedValue['' + propValue[i]] = true;
    }
    for (i = 0; i < options.length; i++) {
      var selected = selectedValue.hasOwnProperty(options[i].value);
      if (options[i].selected !== selected) {
        options[i].selected = selected;
      }
    }
  } else {
    // Do not set `select.value` as exact behavior isn't consistent across all
    // browsers for all cases.
    selectedValue = '' + propValue;
    for (i = 0; i < options.length; i++) {
      if (options[i].value === selectedValue) {
        options[i].selected = true;
        return;
      }
    }
    if (options.length) {
      options[0].selected = true;
    }
  }
}

/**
 * Implements a <select> host component that allows optionally setting the
 * props `value` and `defaultValue`. If `multiple` is false, the prop must be a
 * stringable. If `multiple` is true, the prop must be an array of stringables.
 *
 * If `value` is not supplied (or null/undefined), user actions that change the
 * selected option will trigger updates to the rendered options.
 *
 * If it is supplied (and not null/undefined), the rendered options will not
 * update in response to user actions. Instead, the `value` prop must change in
 * order for the rendered options to update.
 *
 * If `defaultValue` is provided, any options with the supplied values will be
 * selected.
 */
var ReactDOMSelect = {
  getHostProps: function (inst, props) {
    return _assign({}, DisabledInputUtils.getHostProps(inst, props), {
      onChange: inst._wrapperState.onChange,
      value: undefined
    });
  },

mountWrapper: function (inst, props) {
    if (process.env.NODE_ENV !== 'production') {
      checkSelectPropTypes(inst, props);
    }

var value = LinkedValueUtils.getValue(props);
    inst._wrapperState = {
      pendingUpdate: false,
      initialValue: value != null ? value : props.defaultValue,
      listeners: null,
      onChange: _handleChange.bind(inst),
      wasMultiple: Boolean(props.multiple)
    };

if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {
      process.env.NODE_ENV !== 'production' ? warning(false, 'Select elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled select ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components') : void 0;
      didWarnValueDefaultValue = true;
    }
  },

getSelectValueContext: function (inst) {
    // ReactDOMOption looks at this initial value so the initial generated
    // markup has correct `selected` attributes
    return inst._wrapperState.initialValue;
  },

postUpdateWrapper: function (inst) {
    var props = inst._currentElement.props;

// After the initial mount, we control selected-ness manually so don't pass
    // this value down
    inst._wrapperState.initialValue = undefined;

var wasMultiple = inst._wrapperState.wasMultiple;
    inst._wrapperState.wasMultiple = Boolean(props.multiple);

function _handleChange(event) {
  var props = this._currentElement.props;
  var returnValue = LinkedValueUtils.executeOnChange(props, event);

if (this._rootNodeID) {
    this._wrapperState.pendingUpdate = true;
  }
  ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);
  return returnValue;
}

module.exports = ReactDOMSelect;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 526 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * ReactElementValidator provides a wrapper around a element factory
 * which validates the props passed to the element. This is intended to be
 * used only in DEV and could be replaced by a static type checker for languages
 * that support it.
 */

var ReactCurrentOwner = __webpack_require__(63);
var ReactComponentTreeHook = __webpack_require__(50);
var ReactElement = __webpack_require__(51);
var ReactPropTypeLocations = __webpack_require__(195);

var checkReactTypeSpec = __webpack_require__(538);

var canDefineProperty = __webpack_require__(330);
var getIteratorFn = __webpack_require__(335);
var warning = __webpack_require__(18);

/**
 * Warn if there's no key explicitly set on dynamic arrays of children or
 * object keys are not valid. This allows us to keep track of children between
 * updates.
 */
var ownerHasKeyUseWarning = {};

function getCurrentComponentErrorInfo(parentType) {
  var info = getDeclarationErrorAddendum();

if (!info) {
    var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
    if (parentName) {
      info = ' Check the top-level render call using <' + parentName + '>.';
    }
  }
  return info;
}

/**
 * Warn if the element doesn't have an explicit key assigned to it.
 * This element is in an array. The array could grow and shrink or be
 * reordered. All children that haven't already been validated are required to
 * have a "key" property assigned to it. Error statuses are cached so a warning
 * will only be shown once.
 *
 * @internal
 * @param {ReactElement} element Element that requires a key.
 * @param {*} parentType element's parent's type.
 */
function validateExplicitKey(element, parentType) {
  if (!element._store || element._store.validated || element.key != null) {
    return;
  }
  element._store.validated = true;

var memoizer = ownerHasKeyUseWarning.uniqueKey || (ownerHasKeyUseWarning.uniqueKey = {});

var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
  if (memoizer[currentComponentErrorInfo]) {
    return;
  }
  memoizer[currentComponentErrorInfo] = true;

// Usually the current owner is the offender, but if it accepts children as a
  // property, it may be the creator of the child that's responsible for
  // assigning it a key.
  var childOwner = '';
  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
    // Give the component that originally created this child.
    childOwner = ' It was passed a child from ' + element._owner.getName() + '.';
  }

process.env.NODE_ENV !== 'production' ? warning(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, ReactComponentTreeHook.getCurrentStackAddendum(element)) : void 0;
}

/**
 * Ensure that every element either is passed in a static location, in an
 * array with an explicit keys property defined, or in an object literal
 * with valid key property.
 *
 * @internal
 * @param {ReactNode} node Statically passed child of any type.
 * @param {*} parentType node's parent's type.
 */
function validateChildKeys(node, parentType) {
  if (typeof node !== 'object') {
    return;
  }
  if (Array.isArray(node)) {
    for (var i = 0; i < node.length; i++) {
      var child = node[i];
      if (ReactElement.isValidElement(child)) {
        validateExplicitKey(child, parentType);
      }
    }
  } else if (ReactElement.isValidElement(node)) {
    // This element was passed in a valid location.
    if (node._store) {
      node._store.validated = true;
    }
  } else if (node) {
    var iteratorFn = getIteratorFn(node);
    // Entry iterators provide implicit keys.
    if (iteratorFn) {
      if (iteratorFn !== node.entries) {
        var iterator = iteratorFn.call(node);
        var step;
        while (!(step = iterator.next()).done) {
          if (ReactElement.isValidElement(step.value)) {
            validateExplicitKey(step.value, parentType);
          }
        }
      }
    }
  }
}

/**
 * Given an element, validate that its props follow the propTypes definition,
 * provided by the type.
 *
 * @param {ReactElement} element
 */
function validatePropTypes(element) {
  var componentClass = element.type;
  if (typeof componentClass !== 'function') {
    return;
  }
  var name = componentClass.displayName || componentClass.name;
  if (componentClass.propTypes) {
    checkReactTypeSpec(componentClass.propTypes, element.props, ReactPropTypeLocations.prop, name, element, null);
  }
  if (typeof componentClass.getDefaultProps === 'function') {
    process.env.NODE_ENV !== 'production' ? warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
  }
}

var ReactElementValidator = {

createElement: function (type, props, children) {
    var validType = typeof type === 'string' || typeof type === 'function';
    // We warn in this case but don't throw. We expect the element creation to
    // succeed and there will likely be errors in render.
    if (!validType) {
      process.env.NODE_ENV !== 'production' ? warning(false, 'React.createElement: type should not be null, undefined, boolean, or ' + 'number. It should be a string (for DOM elements) or a ReactClass ' + '(for composite components).%s', getDeclarationErrorAddendum()) : void 0;
    }

var element = ReactElement.createElement.apply(this, arguments);

// The result can be nullish if a mock or a custom function is used.
    // TODO: Drop this when these are no longer allowed as the type argument.
    if (element == null) {
      return element;
    }

// Skip key warning if the type isn't valid since our key validation logic
    // doesn't expect a non-string/function type and can throw confusing errors.
    // We don't want exception behavior to differ between dev and prod.
    // (Rendering will throw with a helpful message and as soon as the type is
    // fixed, the key warnings will appear.)
    if (validType) {
      for (var i = 2; i < arguments.length; i++) {
        validateChildKeys(arguments[i], type);
      }
    }

validatePropTypes(element);

return element;
  },

createFactory: function (type) {
    var validatedFactory = ReactElementValidator.createElement.bind(null, type);
    // Legacy hook TODO: Warn if this is accessed
    validatedFactory.type = type;

if (process.env.NODE_ENV !== 'production') {
      if (canDefineProperty) {
        Object.defineProperty(validatedFactory, 'type', {
          enumerable: false,
          get: function () {
            process.env.NODE_ENV !== 'production' ? warning(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.') : void 0;
            Object.defineProperty(this, 'type', {
              value: type
            });
            return type;
          }
        });
      }
    }

return validatedFactory;
  },

cloneElement: function (element, props, children) {
    var newElement = ReactElement.cloneElement.apply(this, arguments);
    for (var i = 2; i < arguments.length; i++) {
      validateChildKeys(arguments[i], newElement.type);
    }
    validatePropTypes(newElement);
    return newElement;
  }

};

module.exports = ReactElementValidator;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 527 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright 2014-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule ReactEmptyComponent
 */

var emptyComponentFactory;

var ReactEmptyComponentInjection = {
  injectEmptyComponentFactory: function (factory) {
    emptyComponentFactory = factory;
  }
};

var ReactEmptyComponent = {
  create: function (instantiate) {
    return emptyComponentFactory(instantiate);
  }
};

ReactEmptyComponent.injection = ReactEmptyComponentInjection;

module.exports = ReactEmptyComponent;

/***/ }),
/* 528 */
/***/ (function(module, exports, __webpack_require__) {

var ReactFeatureFlags = {
  // When true, call console.time() before and .timeEnd() after each top-level
  // render (both initial renders and updates). Useful when looking at prod-mode
  // timeline profiles in Chrome, for example.
  logTopLevelRenders: false
};

module.exports = ReactFeatureFlags;

/***/ }),
/* 529 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21),
    _assign = __webpack_require__(24);

var invariant = __webpack_require__(19);

var genericComponentClass = null;
// This registry keeps track of wrapper classes around host tags.
var tagToComponentClass = {};
var textComponentClass = null;

/**
 * Get a host internal component class for a specific tag.
 *
 * @param {ReactElement} element The element to create.
 * @return {function} The internal class constructor function.
 */
function createInternalComponent(element) {
  !genericComponentClass ? process.env.NODE_ENV !== 'production' ? invariant(false, 'There is no registered component for the tag %s', element.type) : _prodInvariant('111', element.type) : void 0;
  return new genericComponentClass(element);
}

/**
 * @param {ReactText} text
 * @return {ReactComponent}
 */
function createInstanceForText(text) {
  return new textComponentClass(text);
}

/**
 * @param {ReactComponent} component
 * @return {boolean}
 */
function isTextComponent(component) {
  return component instanceof textComponentClass;
}

var ReactHostComponent = {
  createInternalComponent: createInternalComponent,
  createInstanceForText: createInstanceForText,
  isTextComponent: isTextComponent,
  injection: ReactHostComponentInjection
};

module.exports = ReactHostComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 530 */
/***/ (function(module, exports, __webpack_require__) {

var ReactDOMSelection = __webpack_require__(1383);

var containsNode = __webpack_require__(931);
var focusNode = __webpack_require__(411);
var getActiveElement = __webpack_require__(412);

function isInDocument(node) {
  return containsNode(document.documentElement, node);
}

/**
 * @ReactInputSelection: React input selection module. Based on Selection.js,
 * but modified to be suitable for react and has a couple of bug fixes (doesn't
 * assume buttons have range selections allowed).
 * Input selection module for React.
 */
var ReactInputSelection = {

hasSelectionCapabilities: function (elem) {
    var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
    return nodeName && (nodeName === 'input' && elem.type === 'text' || nodeName === 'textarea' || elem.contentEditable === 'true');
  },

getSelectionInformation: function () {
    var focusedElem = getActiveElement();
    return {
      focusedElem: focusedElem,
      selectionRange: ReactInputSelection.hasSelectionCapabilities(focusedElem) ? ReactInputSelection.getSelection(focusedElem) : null
    };
  },

/**
   * @restoreSelection: If any selection information was potentially lost,
   * restore it. This is useful when performing operations that could remove dom
   * nodes and place them back in, resulting in focus being lost.
   */
  restoreSelection: function (priorSelectionInformation) {
    var curFocusedElem = getActiveElement();
    var priorFocusedElem = priorSelectionInformation.focusedElem;
    var priorSelectionRange = priorSelectionInformation.selectionRange;
    if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {
      if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {
        ReactInputSelection.setSelection(priorFocusedElem, priorSelectionRange);
      }
      focusNode(priorFocusedElem);
    }
  },

/**
   * @getSelection: Gets the selection bounds of a focused textarea, input or
   * contentEditable node.
   * -@input: Look up selection bounds of this input
   * -@return {start: selectionStart, end: selectionEnd}
   */
  getSelection: function (input) {
    var selection;

if ('selectionStart' in input) {
      // Modern browser with input or textarea.
      selection = {
        start: input.selectionStart,
        end: input.selectionEnd
      };
    } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {
      // IE8 input.
      var range = document.selection.createRange();
      // There can only be one selection per document in IE, so it must
      // be in our element.
      if (range.parentElement() === input) {
        selection = {
          start: -range.moveStart('character', -input.value.length),
          end: -range.moveEnd('character', -input.value.length)
        };
      }
    } else {
      // Content editable or old IE textarea.
      selection = ReactDOMSelection.getOffsets(input);
    }

return selection || { start: 0, end: 0 };
  },

/**
   * @setSelection: Sets the selection bounds of a textarea or input and focuses
   * the input.
   * -@input     Set selection bounds of this input or textarea
   * -@offsets   Object of same form that is returned from get*
   */
  setSelection: function (input, offsets) {
    var start = offsets.start;
    var end = offsets.end;
    if (end === undefined) {
      end = start;
    }

if ('selectionStart' in input) {
      input.selectionStart = start;
      input.selectionEnd = Math.min(end, input.value.length);
    } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {
      var range = input.createTextRange();
      range.collapse(true);
      range.moveStart('character', start);
      range.moveEnd('character', end - start);
      range.select();
    } else {
      ReactDOMSelection.setOffsets(input, offsets);
    }
  }
};

module.exports = ReactInputSelection;

/***/ }),
/* 531 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var DOMLazyTree = __webpack_require__(113);
var DOMProperty = __webpack_require__(90);
var ReactBrowserEventEmitter = __webpack_require__(194);
var ReactCurrentOwner = __webpack_require__(63);
var ReactDOMComponentTree = __webpack_require__(28);
var ReactDOMContainerInfo = __webpack_require__(1375);
var ReactDOMFeatureFlags = __webpack_require__(1378);
var ReactElement = __webpack_require__(51);
var ReactFeatureFlags = __webpack_require__(528);
var ReactInstanceMap = __webpack_require__(146);
var ReactInstrumentation = __webpack_require__(41);
var ReactMarkupChecksum = __webpack_require__(1396);
var ReactReconciler = __webpack_require__(114);
var ReactUpdateQueue = __webpack_require__(329);
var ReactUpdates = __webpack_require__(57);

var emptyObject = __webpack_require__(131);
var instantiateReactComponent = __webpack_require__(542);
var invariant = __webpack_require__(19);
var setInnerHTML = __webpack_require__(198);
var shouldUpdateReactComponent = __webpack_require__(337);
var warning = __webpack_require__(18);

var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
var ROOT_ATTR_NAME = DOMProperty.ROOT_ATTRIBUTE_NAME;

var ELEMENT_NODE_TYPE = 1;
var DOC_NODE_TYPE = 9;
var DOCUMENT_FRAGMENT_NODE_TYPE = 11;

var instancesByReactRootID = {};

/**
 * Finds the index of the first character
 * that's not common between the two given strings.
 *
 * @return {number} the index of the character where the strings diverge
 */
function firstDifferenceIndex(string1, string2) {
  var minLen = Math.min(string1.length, string2.length);
  for (var i = 0; i < minLen; i++) {
    if (string1.charAt(i) !== string2.charAt(i)) {
      return i;
    }
  }
  return string1.length === string2.length ? -1 : minLen;
}

/**
 * @param {DOMElement|DOMDocument} container DOM element that may contain
 * a React component
 * @return {?*} DOM element that may have the reactRoot ID, or null.
 */
function getReactRootElementInContainer(container) {
  if (!container) {
    return null;
  }

if (container.nodeType === DOC_NODE_TYPE) {
    return container.documentElement;
  } else {
    return container.firstChild;
  }
}

function internalGetID(node) {
  // If node is something like a window, document, or text node, none of
  // which support attributes or a .getAttribute method, gracefully return
  // the empty string, as if the attribute were missing.
  return node.getAttribute && node.getAttribute(ATTR_NAME) || '';
}

/**
 * Mounts this component and inserts it into the DOM.
 *
 * @param {ReactComponent} componentInstance The instance to mount.
 * @param {DOMElement} container DOM element to mount into.
 * @param {ReactReconcileTransaction} transaction
 * @param {boolean} shouldReuseMarkup If true, do not insert markup
 */
function mountComponentIntoNode(wrapperInstance, container, transaction, shouldReuseMarkup, context) {
  var markerName;
  if (ReactFeatureFlags.logTopLevelRenders) {
    var wrappedElement = wrapperInstance._currentElement.props;
    var type = wrappedElement.type;
    markerName = 'React mount: ' + (typeof type === 'string' ? type : type.displayName || type.name);
    console.time(markerName);
  }

var markup = ReactReconciler.mountComponent(wrapperInstance, transaction, null, ReactDOMContainerInfo(wrapperInstance, container), context, 0 /* parentDebugID */
  );

if (markerName) {
    console.timeEnd(markerName);
  }

wrapperInstance._renderedComponent._topLevelWrapper = wrapperInstance;
  ReactMount._mountImageIntoNode(markup, container, wrapperInstance, shouldReuseMarkup, transaction);
}

/**
 * Batched mount.
 *
 * @param {ReactComponent} componentInstance The instance to mount.
 * @param {DOMElement} container DOM element to mount into.
 * @param {boolean} shouldReuseMarkup If true, do not insert markup
 */
function batchedMountComponentIntoNode(componentInstance, container, shouldReuseMarkup, context) {
  var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(
  /* useCreateElement */
  !shouldReuseMarkup && ReactDOMFeatureFlags.useCreateElement);
  transaction.perform(mountComponentIntoNode, null, componentInstance, container, transaction, shouldReuseMarkup, context);
  ReactUpdates.ReactReconcileTransaction.release(transaction);
}

/**
 * Unmounts a component and removes it from the DOM.
 *
 * @param {ReactComponent} instance React component instance.
 * @param {DOMElement} container DOM element to unmount from.
 * @final
 * @internal
 * @see {ReactMount.unmountComponentAtNode}
 */
function unmountComponentFromNode(instance, container, safely) {
  if (process.env.NODE_ENV !== 'production') {
    ReactInstrumentation.debugTool.onBeginFlush();
  }
  ReactReconciler.unmountComponent(instance, safely);
  if (process.env.NODE_ENV !== 'production') {
    ReactInstrumentation.debugTool.onEndFlush();
  }

if (container.nodeType === DOC_NODE_TYPE) {
    container = container.documentElement;
  }

// http://jsperf.com/emptying-a-node
  while (container.lastChild) {
    container.removeChild(container.lastChild);
  }
}

/**
 * True if the supplied DOM node has a direct React-rendered child that is
 * not a React root element. Useful for warning in `render`,
 * `unmountComponentAtNode`, etc.
 *
 * @param {?DOMElement} node The candidate DOM node.
 * @return {boolean} True if the DOM element contains a direct child that was
 * rendered by React but is not a root element.
 * @internal
 */
function hasNonRootReactChild(container) {
  var rootEl = getReactRootElementInContainer(container);
  if (rootEl) {
    var inst = ReactDOMComponentTree.getInstanceFromNode(rootEl);
    return !!(inst && inst._hostParent);
  }
}

/**
 * True if the supplied DOM node is a React DOM element and
 * it has been rendered by another copy of React.
 *
 * @param {?DOMElement} node The candidate DOM node.
 * @return {boolean} True if the DOM has been rendered by another copy of React
 * @internal
 */
function nodeIsRenderedByOtherInstance(container) {
  var rootEl = getReactRootElementInContainer(container);
  return !!(rootEl && isReactNode(rootEl) && !ReactDOMComponentTree.getInstanceFromNode(rootEl));
}

/**
 * True if the supplied DOM node is a valid node element.
 *
 * @param {?DOMElement} node The candidate DOM node.
 * @return {boolean} True if the DOM is a valid DOM node.
 * @internal
 */
function isValidContainer(node) {
  return !!(node && (node.nodeType === ELEMENT_NODE_TYPE || node.nodeType === DOC_NODE_TYPE || node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE));
}

/**
 * True if the supplied DOM node is a valid React node element.
 *
 * @param {?DOMElement} node The candidate DOM node.
 * @return {boolean} True if the DOM is a valid React DOM node.
 * @internal
 */
function isReactNode(node) {
  return isValidContainer(node) && (node.hasAttribute(ROOT_ATTR_NAME) || node.hasAttribute(ATTR_NAME));
}

function getHostRootInstanceInContainer(container) {
  var rootEl = getReactRootElementInContainer(container);
  var prevHostInstance = rootEl && ReactDOMComponentTree.getInstanceFromNode(rootEl);
  return prevHostInstance && !prevHostInstance._hostParent ? prevHostInstance : null;
}

function getTopLevelWrapperInContainer(container) {
  var root = getHostRootInstanceInContainer(container);
  return root ? root._hostContainerInfo._topLevelWrapper : null;
}

/**
 * Temporary (?) hack so that we can store all top-level pending updates on
 * composites instead of having to worry about different types of components
 * here.
 */
var topLevelRootCounter = 1;
var TopLevelWrapper = function () {
  this.rootID = topLevelRootCounter++;
};
TopLevelWrapper.prototype.isReactComponent = {};
if (process.env.NODE_ENV !== 'production') {
  TopLevelWrapper.displayName = 'TopLevelWrapper';
}
TopLevelWrapper.prototype.render = function () {
  // this.props is actually a ReactElement
  return this.props;
};

/**
 * Mounting is the process of initializing a React component by creating its
 * representative DOM elements and inserting them into a supplied `container`.
 * Any prior content inside `container` is destroyed in the process.
 *
 *   ReactMount.render(
 *     component,
 *     document.getElementById('container')
 *   );
 *
 *   <div id="container">                   <-- Supplied `container`.
 *     <div data-reactid=".3">              <-- Rendered reactRoot of React
 *       // ...                                 component.
 *     </div>
 *   </div>
 *
 * Inside of `container`, the first element rendered is the "reactRoot".
 */
var ReactMount = {

TopLevelWrapper: TopLevelWrapper,

/**
   * Used by devtools. The keys are not important.
   */
  _instancesByReactRootID: instancesByReactRootID,

/**
   * This is a hook provided to support rendering React components while
   * ensuring that the apparent scroll position of its `container` does not
   * change.
   *
   * @param {DOMElement} container The `container` being rendered into.
   * @param {function} renderCallback This must be called once to do the render.
   */
  scrollMonitor: function (container, renderCallback) {
    renderCallback();
  },

/**
   * Take a component that's already mounted into the DOM and replace its props
   * @param {ReactComponent} prevComponent component instance already in the DOM
   * @param {ReactElement} nextElement component instance to render
   * @param {DOMElement} container container to render into
   * @param {?function} callback function triggered on completion
   */
  _updateRootComponent: function (prevComponent, nextElement, nextContext, container, callback) {
    ReactMount.scrollMonitor(container, function () {
      ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement, nextContext);
      if (callback) {
        ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);
      }
    });

return prevComponent;
  },

/**
   * Render a new component into the DOM. Hooked by hooks!
   *
   * @param {ReactElement} nextElement element to render
   * @param {DOMElement} container container to render into
   * @param {boolean} shouldReuseMarkup if we should skip the markup insertion
   * @return {ReactComponent} nextComponent
   */
  _renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) {
    // Various parts of our code (such as ReactCompositeComponent's
    // _renderValidatedComponent) assume that calls to render aren't nested;
    // verify that that's the case.
    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '_renderNewRootComponent(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from ' + 'render is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;

!isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, '_registerComponent(...): Target container is not a DOM element.') : _prodInvariant('37') : void 0;

ReactBrowserEventEmitter.ensureScrollValueMonitoring();
    var componentInstance = instantiateReactComponent(nextElement, false);

// The initial render is synchronous but any updates that happen during
    // rendering, in componentWillMount or componentDidMount, will be batched
    // according to the current batching strategy.

ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, container, shouldReuseMarkup, context);

var wrapperID = componentInstance._instance.rootID;
    instancesByReactRootID[wrapperID] = componentInstance;

return componentInstance;
  },

/**
   * Renders a React component into the DOM in the supplied `container`.
   *
   * If the React component was previously rendered into `container`, this will
   * perform an update on it and only mutate the DOM as necessary to reflect the
   * latest React component.
   *
   * @param {ReactComponent} parentComponent The conceptual parent of this render tree.
   * @param {ReactElement} nextElement Component element to render.
   * @param {DOMElement} container DOM element to render into.
   * @param {?function} callback function triggered on completion
   * @return {ReactComponent} Component instance rendered in `container`.
   */
  renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
    !(parentComponent != null && ReactInstanceMap.has(parentComponent)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'parentComponent must be a valid React Component') : _prodInvariant('38') : void 0;
    return ReactMount._renderSubtreeIntoContainer(parentComponent, nextElement, container, callback);
  },

_renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
    ReactUpdateQueue.validateCallback(callback, 'ReactDOM.render');
    !ReactElement.isValidElement(nextElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOM.render(): Invalid component element.%s', typeof nextElement === 'string' ? ' Instead of passing a string like \'div\', pass ' + 'React.createElement(\'div\') or <div />.' : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' :
    // Check if it quacks like an element
    nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : _prodInvariant('39', typeof nextElement === 'string' ? ' Instead of passing a string like \'div\', pass ' + 'React.createElement(\'div\') or <div />.' : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' : nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : void 0;

process.env.NODE_ENV !== 'production' ? warning(!container || !container.tagName || container.tagName.toUpperCase() !== 'BODY', 'render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.') : void 0;

var nextWrappedElement = ReactElement(TopLevelWrapper, null, null, null, null, null, nextElement);

var nextContext;
    if (parentComponent) {
      var parentInst = ReactInstanceMap.get(parentComponent);
      nextContext = parentInst._processChildContext(parentInst._context);
    } else {
      nextContext = emptyObject;
    }

var prevComponent = getTopLevelWrapperInContainer(container);

if (prevComponent) {
      var prevWrappedElement = prevComponent._currentElement;
      var prevElement = prevWrappedElement.props;
      if (shouldUpdateReactComponent(prevElement, nextElement)) {
        var publicInst = prevComponent._renderedComponent.getPublicInstance();
        var updatedCallback = callback && function () {
          callback.call(publicInst);
        };
        ReactMount._updateRootComponent(prevComponent, nextWrappedElement, nextContext, container, updatedCallback);
        return publicInst;
      } else {
        ReactMount.unmountComponentAtNode(container);
      }
    }

var reactRootElement = getReactRootElementInContainer(container);
    var containerHasReactMarkup = reactRootElement && !!internalGetID(reactRootElement);
    var containerHasNonRootReactChild = hasNonRootReactChild(container);

if (process.env.NODE_ENV !== 'production') {
      process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.') : void 0;

if (!containerHasReactMarkup || reactRootElement.nextSibling) {
        var rootElementSibling = reactRootElement;
        while (rootElementSibling) {
          if (internalGetID(rootElementSibling)) {
            process.env.NODE_ENV !== 'production' ? warning(false, 'render(): Target node has markup rendered by React, but there ' + 'are unrelated nodes as well. This is most commonly caused by ' + 'white-space inserted around server-rendered markup.') : void 0;
            break;
          }
          rootElementSibling = rootElementSibling.nextSibling;
        }
      }
    }

var shouldReuseMarkup = containerHasReactMarkup && !prevComponent && !containerHasNonRootReactChild;
    var component = ReactMount._renderNewRootComponent(nextWrappedElement, container, shouldReuseMarkup, nextContext)._renderedComponent.getPublicInstance();
    if (callback) {
      callback.call(component);
    }
    return component;
  },

/**
   * Renders a React component into the DOM in the supplied `container`.
   * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.render
   *
   * If the React component was previously rendered into `container`, this will
   * perform an update on it and only mutate the DOM as necessary to reflect the
   * latest React component.
   *
   * @param {ReactElement} nextElement Component element to render.
   * @param {DOMElement} container DOM element to render into.
   * @param {?function} callback function triggered on completion
   * @return {ReactComponent} Component instance rendered in `container`.
   */
  render: function (nextElement, container, callback) {
    return ReactMount._renderSubtreeIntoContainer(null, nextElement, container, callback);
  },

/**
   * Unmounts and destroys the React component rendered in the `container`.
   * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.unmountcomponentatnode
   *
   * @param {DOMElement} container DOM element containing a React component.
   * @return {boolean} True if a component was found in and unmounted from
   *                   `container`
   */
  unmountComponentAtNode: function (container) {
    // Various parts of our code (such as ReactCompositeComponent's
    // _renderValidatedComponent) assume that calls to render aren't nested;
    // verify that that's the case. (Strictly speaking, unmounting won't cause a
    // render but we still don't expect to be in a render call here.)
    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, 'unmountComponentAtNode(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from render ' + 'is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;

!isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'unmountComponentAtNode(...): Target container is not a DOM element.') : _prodInvariant('40') : void 0;

if (process.env.NODE_ENV !== 'production') {
      process.env.NODE_ENV !== 'production' ? warning(!nodeIsRenderedByOtherInstance(container), 'unmountComponentAtNode(): The node you\'re attempting to unmount ' + 'was rendered by another copy of React.') : void 0;
    }

var prevComponent = getTopLevelWrapperInContainer(container);
    if (!prevComponent) {
      // Check if the node being unmounted was rendered by React, but isn't a
      // root node.
      var containerHasNonRootReactChild = hasNonRootReactChild(container);

// Check if the container itself is a React root node.
      var isContainerReactRoot = container.nodeType === 1 && container.hasAttribute(ROOT_ATTR_NAME);

if (process.env.NODE_ENV !== 'production') {
        process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'unmountComponentAtNode(): The node you\'re attempting to unmount ' + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.') : void 0;
      }

return false;
    }
    delete instancesByReactRootID[prevComponent._instance.rootID];
    ReactUpdates.batchedUpdates(unmountComponentFromNode, prevComponent, container, false);
    return true;
  },

_mountImageIntoNode: function (markup, container, instance, shouldReuseMarkup, transaction) {
    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mountComponentIntoNode(...): Target container is not valid.') : _prodInvariant('41') : void 0;

if (shouldReuseMarkup) {
      var rootElement = getReactRootElementInContainer(container);
      if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {
        ReactDOMComponentTree.precacheNode(instance, rootElement);
        return;
      } else {
        var checksum = rootElement.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
        rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);

var rootMarkup = rootElement.outerHTML;
        rootElement.setAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME, checksum);

var diffIndex = firstDifferenceIndex(normalizedMarkup, rootMarkup);
        var difference = ' (client) ' + normalizedMarkup.substring(diffIndex - 20, diffIndex + 20) + '\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);

!(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\'re trying to render a component to the document using server rendering but the checksum was invalid. This usually means you rendered a different component type or props on the client from the one on the server, or your render() methods are impure. React cannot handle this case due to cross-browser quirks by rendering at the document root. You should look for environment dependent code in your components and ensure the props are the same client and server side:\n%s', difference) : _prodInvariant('42', difference) : void 0;

if (process.env.NODE_ENV !== 'production') {
          process.env.NODE_ENV !== 'production' ? warning(false, 'React attempted to reuse markup in a container but the ' + 'checksum was invalid. This generally means that you are ' + 'using server rendering and the markup generated on the ' + 'server was not what the client was expecting. React injected ' + 'new markup to compensate which works but you have lost many ' + 'of the benefits of server rendering. Instead, figure out ' + 'why the markup being generated is different on the client ' + 'or server:\n%s', difference) : void 0;
        }
      }
    }

!(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\'re trying to render a component to the document but you didn\'t use server rendering. We can\'t do this without using server rendering due to cross-browser quirks. See ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('43') : void 0;

if (transaction.useCreateElement) {
      while (container.lastChild) {
        container.removeChild(container.lastChild);
      }
      DOMLazyTree.insertTreeBefore(container, markup, null);
    } else {
      setInnerHTML(container, markup);
      ReactDOMComponentTree.precacheNode(instance, container.firstChild);
    }

if (process.env.NODE_ENV !== 'production') {
      var hostNode = ReactDOMComponentTree.getInstanceFromNode(container.firstChild);
      if (hostNode._debugID !== 0) {
        ReactInstrumentation.debugTool.onHostOperation(hostNode._debugID, 'mount', markup.toString());
      }
    }
  }
};

module.exports = ReactMount;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 532 */
/***/ (function(module, exports, __webpack_require__) {

var keyMirror = __webpack_require__(167);

/**
 * When a component's children are updated, a series of update configuration
 * objects are created in order to batch and serialize the required changes.
 *
 * Enumerates all the possible types of update configurations.
 *
 * @internal
 */
var ReactMultiChildUpdateTypes = keyMirror({
  INSERT_MARKUP: null,
  MOVE_EXISTING: null,
  REMOVE_NODE: null,
  SET_MARKUP: null,
  TEXT_CONTENT: null
});

module.exports = ReactMultiChildUpdateTypes;

/***/ }),
/* 533 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var ReactElement = __webpack_require__(51);

var invariant = __webpack_require__(19);

var ReactNodeTypes = {
  HOST: 0,
  COMPOSITE: 1,
  EMPTY: 2,

getType: function (node) {
    if (node === null || node === false) {
      return ReactNodeTypes.EMPTY;
    } else if (ReactElement.isValidElement(node)) {
      if (typeof node.type === 'function') {
        return ReactNodeTypes.COMPOSITE;
      } else {
        return ReactNodeTypes.HOST;
      }
    }
     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unexpected node: %s', node) : _prodInvariant('26', node) : void 0;
  }
};

module.exports = ReactNodeTypes;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 534 */
/***/ (function(module, exports, __webpack_require__) {

var ReactElement = __webpack_require__(51);
var ReactPropTypeLocationNames = __webpack_require__(327);
var ReactPropTypesSecret = __webpack_require__(328);

var emptyFunction = __webpack_require__(44);
var getIteratorFn = __webpack_require__(335);
var warning = __webpack_require__(18);

/**
 * Collection of methods that allow declaration and validation of props that are
 * supplied to React components. Example usage:
 *
 *   var Props = require('ReactPropTypes');
 *   var MyArticle = React.createClass({
 *     propTypes: {
 *       // An optional string prop named "description".
 *       description: Props.string,
 *
 *       // A required enum prop named "category".
 *       category: Props.oneOf(['News','Photos']).isRequired,
 *
 *       // A prop named "dialog" that requires an instance of Dialog.
 *       dialog: Props.instanceOf(Dialog).isRequired
 *     },
 *     render: function() { ... }
 *   });
 *
 * A more formal specification of how these methods are used:
 *
 *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
 *   decl := ReactPropTypes.{type}(.isRequired)?
 *
 * Each and every declaration produces a function with the same signature. This
 * allows the creation of custom validation functions. For example:
 *
 *  var MyLink = React.createClass({
 *    propTypes: {
 *      // An optional string or URI prop named "href".
 *      href: function(props, propName, componentName) {
 *        var propValue = props[propName];
 *        if (propValue != null && typeof propValue !== 'string' &&
 *            !(propValue instanceof URI)) {
 *          return new Error(
 *            'Expected a string or an URI for ' + propName + ' in ' +
 *            componentName
 *          );
 *        }
 *      }
 *    },
 *    render: function() {...}
 *  });
 *
 * @internal
 */

var ANONYMOUS = '<<anonymous>>';

var ReactPropTypes = {
  array: createPrimitiveTypeChecker('array'),
  bool: createPrimitiveTypeChecker('boolean'),
  func: createPrimitiveTypeChecker('function'),
  number: createPrimitiveTypeChecker('number'),
  object: createPrimitiveTypeChecker('object'),
  string: createPrimitiveTypeChecker('string'),
  symbol: createPrimitiveTypeChecker('symbol'),

any: createAnyTypeChecker(),
  arrayOf: createArrayOfTypeChecker,
  element: createElementTypeChecker(),
  instanceOf: createInstanceTypeChecker,
  node: createNodeChecker(),
  objectOf: createObjectOfTypeChecker,
  oneOf: createEnumTypeChecker,
  oneOfType: createUnionTypeChecker,
  shape: createShapeTypeChecker
};

/**
 * inlined Object.is polyfill to avoid requiring consumers ship their own
 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
 */
/*eslint-disable no-self-compare*/
function is(x, y) {
  // SameValue algorithm
  if (x === y) {
    // Steps 1-5, 7-10
    // Steps 6.b-6.e: +0 != -0
    return x !== 0 || 1 / x === 1 / y;
  } else {
    // Step 6.a: NaN == NaN
    return x !== x && y !== y;
  }
}
/*eslint-enable no-self-compare*/

/**
 * We use an Error-like object for backward compatibility as people may call
 * PropTypes directly and inspect their output. However we don't use real
 * Errors anymore. We don't inspect their stack anyway, and creating them
 * is prohibitively expensive if they are created too often, such as what
 * happens in oneOfType() for any type before the one that matched.
 */
function PropTypeError(message) {
  this.message = message;
  this.stack = '';
}
// Make `instanceof Error` still work for returned errors.
PropTypeError.prototype = Error.prototype;

var chainedCheckType = checkType.bind(null, false);
  chainedCheckType.isRequired = checkType.bind(null, true);

return chainedCheckType;
}

function createPrimitiveTypeChecker(expectedType) {
  function validate(props, propName, componentName, location, propFullName, secret) {
    var propValue = props[propName];
    var propType = getPropType(propValue);
    if (propType !== expectedType) {
      var locationName = ReactPropTypeLocationNames[location];
      // `propValue` being instance of, say, date/regexp, pass the 'object'
      // check, but we can offer a more precise error message here rather than
      // 'of type `object`'.
      var preciseType = getPreciseType(propValue);

return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
    }
    return null;
  }
  return createChainableTypeChecker(validate);
}

function createAnyTypeChecker() {
  return createChainableTypeChecker(emptyFunction.thatReturns(null));
}

function createEnumTypeChecker(expectedValues) {
  if (!Array.isArray(expectedValues)) {
    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
    return emptyFunction.thatReturnsNull;
  }

function validate(props, propName, componentName, location, propFullName) {
    var propValue = props[propName];
    for (var i = 0; i < expectedValues.length; i++) {
      if (is(propValue, expectedValues[i])) {
        return null;
      }
    }

var locationName = ReactPropTypeLocationNames[location];
    var valuesString = JSON.stringify(expectedValues);
    return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
  }
  return createChainableTypeChecker(validate);
}

function createUnionTypeChecker(arrayOfTypeCheckers) {
  if (!Array.isArray(arrayOfTypeCheckers)) {
    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
    return emptyFunction.thatReturnsNull;
  }

function validate(props, propName, componentName, location, propFullName) {
    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
      var checker = arrayOfTypeCheckers[i];
      if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
        return null;
      }
    }

var locationName = ReactPropTypeLocationNames[location];
    return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
  }
  return createChainableTypeChecker(validate);
}

function isNode(propValue) {
  switch (typeof propValue) {
    case 'number':
    case 'string':
    case 'undefined':
      return true;
    case 'boolean':
      return !propValue;
    case 'object':
      if (Array.isArray(propValue)) {
        return propValue.every(isNode);
      }
      if (propValue === null || ReactElement.isValidElement(propValue)) {
        return true;
      }

return true;
    default:
      return false;
  }
}

function isSymbol(propType, propValue) {
  // Native Symbol.
  if (propType === 'symbol') {
    return true;
  }

// 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
  if (propValue['@@toStringTag'] === 'Symbol') {
    return true;
  }

// Fallback for non-spec compliant Symbols which are polyfilled.
  if (typeof Symbol === 'function' && propValue instanceof Symbol) {
    return true;
  }

return false;
}

// Equivalent of `typeof` but with special handling for array and regexp.
function getPropType(propValue) {
  var propType = typeof propValue;
  if (Array.isArray(propValue)) {
    return 'array';
  }
  if (propValue instanceof RegExp) {
    // Old webkits (at least until Android 4.0) return 'function' rather than
    // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
    // passes PropTypes.object.
    return 'object';
  }
  if (isSymbol(propType, propValue)) {
    return 'symbol';
  }
  return propType;
}

// This handles more types than `getPropType`. Only used for error messages.
// See `createPrimitiveTypeChecker`.
function getPreciseType(propValue) {
  var propType = getPropType(propValue);
  if (propType === 'object') {
    if (propValue instanceof Date) {
      return 'date';
    } else if (propValue instanceof RegExp) {
      return 'regexp';
    }
  }
  return propType;
}

// Returns class name of the object, if any.
function getClassName(propValue) {
  if (!propValue.constructor || !propValue.constructor.name) {
    return ANONYMOUS;
  }
  return propValue.constructor.name;
}

module.exports = ReactPropTypes;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 535 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = '15.3.2';

/***/ }),
/* 536 */
/***/ (function(module, exports, __webpack_require__) {

var ViewportMetrics = {

currentScrollLeft: 0,

currentScrollTop: 0,

refreshScrollValues: function (scrollPosition) {
    ViewportMetrics.currentScrollLeft = scrollPosition.x;
    ViewportMetrics.currentScrollTop = scrollPosition.y;
  }

};

module.exports = ViewportMetrics;

/***/ }),
/* 537 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var invariant = __webpack_require__(19);

/**
 * Accumulates items that must not be null or undefined into the first one. This
 * is used to conserve memory by avoiding array allocations, and thus sacrifices
 * API cleanness. Since `current` can be null before being passed in and not
 * null after this function, make sure to assign it back to `current`:
 *
 * `a = accumulateInto(a, b);`
 *
 * This API should be sparingly used. Try `accumulate` for something cleaner.
 *
 * @return {*|array<*>} An accumulation of items.
 */

function accumulateInto(current, next) {
  !(next != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : _prodInvariant('30') : void 0;

if (current == null) {
    return next;
  }

// Both are not empty. Warning: Never call x.concat(y) when you are not
  // certain that x is an Array (x could be a string with concat method).
  if (Array.isArray(current)) {
    if (Array.isArray(next)) {
      current.push.apply(current, next);
      return current;
    }
    current.push(next);
    return current;
  }

if (Array.isArray(next)) {
    // A bit too dangerous to mutate `next`.
    return [current].concat(next);
  }

return [current, next];
}

module.exports = accumulateInto;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 538 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21);

var ReactPropTypeLocationNames = __webpack_require__(327);
var ReactPropTypesSecret = __webpack_require__(328);

var invariant = __webpack_require__(19);
var warning = __webpack_require__(18);

var ReactComponentTreeHook;

if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
  // Temporary hack.
  // Inline requires don't work well with Jest:
  // https://github.com/facebook/react/issues/7240
  // Remove the inline requires when we don't need them anymore:
  // https://github.com/facebook/react/pull/7178
  ReactComponentTreeHook = __webpack_require__(50);
}

var loggedTypeFailures = {};

/**
 * Assert that the values match with the type specs.
 * Error messages are memorized and will only be shown once.
 *
 * @param {object} typeSpecs Map of name to a ReactPropType
 * @param {object} values Runtime values that need to be type-checked
 * @param {string} location e.g. "prop", "context", "child context"
 * @param {string} componentName Name of the component for error messages.
 * @param {?object} element The React element that is being type-checked
 * @param {?number} debugID The React component instance that is being type-checked
 * @private
 */
function checkReactTypeSpec(typeSpecs, values, location, componentName, element, debugID) {
  for (var typeSpecName in typeSpecs) {
    if (typeSpecs.hasOwnProperty(typeSpecName)) {
      var error;
      // Prop type validation may throw. In case they do, we don't want to
      // fail the render phase where it didn't fail before. So we log it.
      // After these have been cleaned up, we'll let them throw.
      try {
        // This is intentionally an invariant that gets caught. It's the same
        // behavior as without this statement except with a better message.
        !(typeof typeSpecs[typeSpecName] === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : _prodInvariant('84', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : void 0;
        error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
      } catch (ex) {
        error = ex;
      }
      process.env.NODE_ENV !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName, typeof error) : void 0;
      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
        // Only monitor this failure once because there tends to be a lot of the
        // same error.
        loggedTypeFailures[error.message] = true;

var componentStackInfo = '';

if (process.env.NODE_ENV !== 'production') {
          if (!ReactComponentTreeHook) {
            ReactComponentTreeHook = __webpack_require__(50);
          }
          if (debugID !== null) {
            componentStackInfo = ReactComponentTreeHook.getStackAddendumByID(debugID);
          } else if (element !== null) {
            componentStackInfo = ReactComponentTreeHook.getCurrentStackAddendum(element);
          }
        }

process.env.NODE_ENV !== 'production' ? warning(false, 'Failed %s type: %s%s', location, error.message, componentStackInfo) : void 0;
      }
    }
  }
}

module.exports = checkReactTypeSpec;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 539 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * @param {array} arr an "accumulation" of items which is either an Array or
 * a single item. Useful when paired with the `accumulate` module. This is a
 * simple utility that allows us to reason about a collection of items, but
 * handling the case when there is exactly one item (and we do not need to
 * allocate an array).
 */

function forEachAccumulated(arr, cb, scope) {
  if (Array.isArray(arr)) {
    arr.forEach(cb, scope);
  } else if (arr) {
    cb.call(scope, arr);
  }
}

module.exports = forEachAccumulated;

/***/ }),
/* 540 */
/***/ (function(module, exports, __webpack_require__) {

var ReactNodeTypes = __webpack_require__(533);

function getHostComponentFromComposite(inst) {
  var type;

while ((type = inst._renderedNodeType) === ReactNodeTypes.COMPOSITE) {
    inst = inst._renderedComponent;
  }

if (type === ReactNodeTypes.HOST) {
    return inst._renderedComponent;
  } else if (type === ReactNodeTypes.EMPTY) {
    return null;
  }
}

module.exports = getHostComponentFromComposite;

/***/ }),
/* 541 */
/***/ (function(module, exports, __webpack_require__) {

var ExecutionEnvironment = __webpack_require__(30);

var contentKey = null;

/**
 * Gets the key used to access text content on a DOM node.
 *
 * @return {?string} Key used to access text content.
 * @internal
 */
function getTextContentAccessor() {
  if (!contentKey && ExecutionEnvironment.canUseDOM) {
    // Prefer textContent to innerText because many browsers support both but
    // SVG <text> elements don't support innerText even when <div> does.
    contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText';
  }
  return contentKey;
}

module.exports = getTextContentAccessor;

/***/ }),
/* 542 */
/***/ (function(module, exports, __webpack_require__) {

var _prodInvariant = __webpack_require__(21),
    _assign = __webpack_require__(24);

var ReactCompositeComponent = __webpack_require__(1371);
var ReactEmptyComponent = __webpack_require__(527);
var ReactHostComponent = __webpack_require__(529);

var invariant = __webpack_require__(19);
var warning = __webpack_require__(18);

// To avoid a cyclic dependency, we create the final class in this module
var ReactCompositeComponentWrapper = function (element) {
  this.construct(element);
};
_assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent.Mixin, {
  _instantiateReactComponent: instantiateReactComponent
});

function getDeclarationErrorAddendum(owner) {
  if (owner) {
    var name = owner.getName();
    if (name) {
      return ' Check the render method of `' + name + '`.';
    }
  }
  return '';
}

/**
 * Check if the type reference is a known internal type. I.e. not a user
 * provided composite type.
 *
 * @param {function} type
 * @return {boolean} Returns true if this is a valid internal type.
 */
function isInternalComponentType(type) {
  return typeof type === 'function' && typeof type.prototype !== 'undefined' && typeof type.prototype.mountComponent === 'function' && typeof type.prototype.receiveComponent === 'function';
}

var nextDebugID = 1;

/**
 * Given a ReactNode, create an instance that will actually be mounted.
 *
 * @param {ReactNode} node
 * @param {boolean} shouldHaveDebugID
 * @return {object} A new instance of the element's constructor.
 * @protected
 */
function instantiateReactComponent(node, shouldHaveDebugID) {
  var instance;

if (node === null || node === false) {
    instance = ReactEmptyComponent.create(instantiateReactComponent);
  } else if (typeof node === 'object') {
    var element = node;
    !(element && (typeof element.type === 'function' || typeof element.type === 'string')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : _prodInvariant('130', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : void 0;

// Special case string values
    if (typeof element.type === 'string') {
      instance = ReactHostComponent.createInternalComponent(element);
    } else if (isInternalComponentType(element.type)) {
      // This is temporarily available for custom components that are not string
      // representations. I.e. ART. Once those are updated to use the string
      // representation, we can drop this code path.
      instance = new element.type(element);

// We renamed this. Allow the old name for compat. :(
      if (!instance.getHostNode) {
        instance.getHostNode = instance.getNativeNode;
      }
    } else {
      instance = new ReactCompositeComponentWrapper(element);
    }
  } else if (typeof node === 'string' || typeof node === 'number') {
    instance = ReactHostComponent.createInstanceForText(node);
  } else {
     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : _prodInvariant('131', typeof node) : void 0;
  }

if (process.env.NODE_ENV !== 'production') {
    process.env.NODE_ENV !== 'production' ? warning(typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.getHostNode === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : void 0;
  }

// These two fields are used by the DOM and ART diffing algorithms
  // respectively. Instead of using expandos on components, we should be
  // storing the state needed by the diffing algorithms elsewhere.
  instance._mountIndex = 0;
  instance._mountImage = null;

if (process.env.NODE_ENV !== 'production') {
    instance._debugID = shouldHaveDebugID ? nextDebugID++ : 0;
  }

// Internal instances should fully constructed at this point, so they should
  // not get any new fields added to them at this point.
  if (process.env.NODE_ENV !== 'production') {
    if (Object.preventExtensions) {
      Object.preventExtensions(instance);
    }
  }

return instance;
}

module.exports = instantiateReactComponent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 543 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
 */

var supportedInputTypes = {
  'color': true,
  'date': true,
  'datetime': true,
  'datetime-local': true,
  'email': true,
  'month': true,
  'number': true,
  'password': true,
  'range': true,
  'search': true,
  'tel': true,
  'text': true,
  'time': true,
  'url': true,
  'week': true
};

function isTextInputElement(elem) {
  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();

if (nodeName === 'input') {
    return !!supportedInputTypes[elem.type];
  }

if (nodeName === 'textarea') {
    return true;
  }

return false;
}

module.exports = isTextInputElement;

/***/ }),
/* 544 */
/***/ (function(module, exports, __webpack_require__) {

var ExecutionEnvironment = __webpack_require__(30);
var escapeTextContentForBrowser = __webpack_require__(197);
var setInnerHTML = __webpack_require__(198);

/**
 * Set the textContent property of a node, ensuring that whitespace is preserved
 * even in IE8. innerText is a poor substitute for textContent and, among many
 * issues, inserts <br> instead of the literal newline chars. innerHTML behaves
 * as it should.
 *
 * @param {DOMElement} node
 * @param {string} text
 * @internal
 */
var setTextContent = function (node, text) {
  if (text) {
    var firstChild = node.firstChild;

if (firstChild && firstChild === node.lastChild && firstChild.nodeType === 3) {
      firstChild.nodeValue = text;
      return;
    }
  }
  node.textContent = text;
};

if (ExecutionEnvironment.canUseDOM) {
  if (!('textContent' in document.documentElement)) {
    setTextContent = function (node, text) {
      setInnerHTML(node, escapeTextContentForBrowser(text));
    };
  }
}

module.exports = setTextContent;

/***/ }),
/* 545 */
/***/ (function(module, exports, __webpack_require__) {

var shallowEqual = __webpack_require__(168);

/**
 * Does a shallow comparison for props and state.
 * See ReactComponentWithPureRenderMixin
 * See also https://facebook.github.io/react/docs/shallow-compare.html
 */
function shallowCompare(instance, nextProps, nextState) {
  return !shallowEqual(instance.props, nextProps) || !shallowEqual(instance.state, nextState);
}

module.exports = shallowCompare;

/***/ }),
/* 546 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports["default"] = compose;
/**
 * Composes single-argument functions from right to left. The rightmost
 * function can take multiple arguments as it provides the signature for
 * the resulting composite function.
 *
 * @param {...Function} funcs The functions to compose.
 * @returns {Function} A function obtained by composing the argument functions
 * from right to left. For example, compose(f, g, h) is identical to doing
 * (...args) => f(g(h(...args))).
 */

function compose() {
  for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
    funcs[_key] = arguments[_key];
  }

if (funcs.length === 0) {
    return function (arg) {
      return arg;
    };
  } else {
    var _ret = function () {
      var last = funcs[funcs.length - 1];
      var rest = funcs.slice(0, -1);
      return {
        v: function v() {
          return rest.reduceRight(function (composed, f) {
            return f(composed);
          }, last.apply(undefined, arguments));
        }
      };
    }();

if (typeof _ret === "object") return _ret.v;
  }
}

/***/ }),
/* 547 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.ActionTypes = undefined;
exports["default"] = createStore;

var _isPlainObject = __webpack_require__(48);

var _isPlainObject2 = _interopRequireDefault(_isPlainObject);

var _symbolObservable = __webpack_require__(1438);

var _symbolObservable2 = _interopRequireDefault(_symbolObservable);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * These are private action types reserved by Redux.
 * For any unknown actions, you must return the current state.
 * If the current state is undefined, you must return the initial state.
 * Do not reference these action types directly in your code.
 */
var ActionTypes = exports.ActionTypes = {
  INIT: '@@redux/INIT'
};

/**
 * Creates a Redux store that holds the state tree.
 * The only way to change the data in the store is to call `dispatch()` on it.
 *
 * There should only be a single store in your app. To specify how different
 * parts of the state tree respond to actions, you may combine several reducers
 * into a single reducer function by using `combineReducers`.
 *
 * @param {Function} reducer A function that returns the next state tree, given
 * the current state tree and the action to handle.
 *
 * @param {any} [initialState] The initial state. You may optionally specify it
 * to hydrate the state from the server in universal apps, or to restore a
 * previously serialized user session.
 * If you use `combineReducers` to produce the root reducer function, this must be
 * an object with the same shape as `combineReducers` keys.
 *
 * @param {Function} enhancer The store enhancer. You may optionally specify it
 * to enhance the store with third-party capabilities such as middleware,
 * time travel, persistence, etc. The only store enhancer that ships with Redux
 * is `applyMiddleware()`.
 *
 * @returns {Store} A Redux store that lets you read the state, dispatch actions
 * and subscribe to changes.
 */
function createStore(reducer, initialState, enhancer) {
  var _ref2;

if (typeof initialState === 'function' && typeof enhancer === 'undefined') {
    enhancer = initialState;
    initialState = undefined;
  }

if (typeof enhancer !== 'undefined') {
    if (typeof enhancer !== 'function') {
      throw new Error('Expected the enhancer to be a function.');
    }

return enhancer(createStore)(reducer, initialState);
  }

if (typeof reducer !== 'function') {
    throw new Error('Expected the reducer to be a function.');
  }

var currentReducer = reducer;
  var currentState = initialState;
  var currentListeners = [];
  var nextListeners = currentListeners;
  var isDispatching = false;

function ensureCanMutateNextListeners() {
    if (nextListeners === currentListeners) {
      nextListeners = currentListeners.slice();
    }
  }

/**
   * Reads the state tree managed by the store.
   *
   * @returns {any} The current state tree of your application.
   */
  function getState() {
    return currentState;
  }

/**
   * Adds a change listener. It will be called any time an action is dispatched,
   * and some part of the state tree may potentially have changed. You may then
   * call `getState()` to read the current state tree inside the callback.
   *
   * You may call `dispatch()` from a change listener, with the following
   * caveats:
   *
   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
   * If you subscribe or unsubscribe while the listeners are being invoked, this
   * will not have any effect on the `dispatch()` that is currently in progress.
   * However, the next `dispatch()` call, whether nested or not, will use a more
   * recent snapshot of the subscription list.
   *
   * 2. The listener should not expect to see all state changes, as the state
   * might have been updated multiple times during a nested `dispatch()` before
   * the listener is called. It is, however, guaranteed that all subscribers
   * registered before the `dispatch()` started will be called with the latest
   * state by the time it exits.
   *
   * @param {Function} listener A callback to be invoked on every dispatch.
   * @returns {Function} A function to remove this change listener.
   */
  function subscribe(listener) {
    if (typeof listener !== 'function') {
      throw new Error('Expected listener to be a function.');
    }

var isSubscribed = true;

ensureCanMutateNextListeners();
    nextListeners.push(listener);

return function unsubscribe() {
      if (!isSubscribed) {
        return;
      }

isSubscribed = false;

ensureCanMutateNextListeners();
      var index = nextListeners.indexOf(listener);
      nextListeners.splice(index, 1);
    };
  }

/**
   * Dispatches an action. It is the only way to trigger a state change.
   *
   * The `reducer` function, used to create the store, will be called with the
   * current state tree and the given `action`. Its return value will
   * be considered the **next** state of the tree, and the change listeners
   * will be notified.
   *
   * The base implementation only supports plain object actions. If you want to
   * dispatch a Promise, an Observable, a thunk, or something else, you need to
   * wrap your store creating function into the corresponding middleware. For
   * example, see the documentation for the `redux-thunk` package. Even the
   * middleware will eventually dispatch plain object actions using this method.
   *
   * @param {Object} action A plain object representing “what changed”. It is
   * a good idea to keep actions serializable so you can record and replay user
   * sessions, or use the time travelling `redux-devtools`. An action must have
   * a `type` property which may not be `undefined`. It is a good idea to use
   * string constants for action types.
   *
   * @returns {Object} For convenience, the same action object you dispatched.
   *
   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
   * return something else (for example, a Promise you can await).
   */
  function dispatch(action) {
    if (!(0, _isPlainObject2["default"])(action)) {
      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
    }

if (typeof action.type === 'undefined') {
      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
    }

if (isDispatching) {
      throw new Error('Reducers may not dispatch actions.');
    }

try {
      isDispatching = true;
      currentState = currentReducer(currentState, action);
    } finally {
      isDispatching = false;
    }

var listeners = currentListeners = nextListeners;
    for (var i = 0; i < listeners.length; i++) {
      listeners[i]();
    }

return action;
  }

/**
   * Replaces the reducer currently used by the store to calculate the state.
   *
   * You might need this if your app implements code splitting and you want to
   * load some of the reducers dynamically. You might also need this if you
   * implement a hot reloading mechanism for Redux.
   *
   * @param {Function} nextReducer The reducer for the store to use instead.
   * @returns {void}
   */
  function replaceReducer(nextReducer) {
    if (typeof nextReducer !== 'function') {
      throw new Error('Expected the nextReducer to be a function.');
    }

currentReducer = nextReducer;
    dispatch({ type: ActionTypes.INIT });
  }

/**
   * Interoperability point for observable/reactive libraries.
   * @returns {observable} A minimal observable of state changes.
   * For more information, see the observable proposal:
   * https://github.com/zenparsing/es-observable
   */
  function observable() {
    var _ref;

var outerSubscribe = subscribe;
    return _ref = {
      /**
       * The minimal observable subscription method.
       * @param {Object} observer Any object that can be used as an observer.
       * The observer object should have a `next` method.
       * @returns {subscription} An object with an `unsubscribe` method that can
       * be used to unsubscribe the observable from the store, and prevent further
       * emission of values from the observable.
       */

subscribe: function subscribe(observer) {
        if (typeof observer !== 'object') {
          throw new TypeError('Expected the observer to be an object.');
        }

function observeState() {
          if (observer.next) {
            observer.next(getState());
          }
        }

observeState();
        var unsubscribe = outerSubscribe(observeState);
        return { unsubscribe: unsubscribe };
      }
    }, _ref[_symbolObservable2["default"]] = function () {
      return this;
    }, _ref;
  }

// When a store is created, an "INIT" action is dispatched so that every
  // reducer returns their initial state. This effectively populates
  // the initial state tree.
  dispatch({ type: ActionTypes.INIT });

return _ref2 = {
    dispatch: dispatch,
    subscribe: subscribe,
    getState: getState,
    replaceReducer: replaceReducer
  }, _ref2[_symbolObservable2["default"]] = observable, _ref2;
}

/***/ }),
/* 548 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports["default"] = warning;
/**
 * Prints a warning in the console if it exists.
 *
 * @param {String} message The warning message.
 * @returns {void}
 */
function warning(message) {
  /* eslint-disable no-console */
  if (typeof console !== 'undefined' && typeof console.error === 'function') {
    console.error(message);
  }
  /* eslint-enable no-console */
  try {
    // This error was thrown as a convenience so that if you enable
    // "break on all exceptions" in your console,
    // it would pause the execution at this line.
    throw new Error(message);
    /* eslint-disable no-empty */
  } catch (e) {}
  /* eslint-enable no-empty */
}

/***/ }),
/* 549 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $Object = Object;
var $TypeError = TypeError;

module.exports = function flags() {
	if (this != null && this !== $Object(this)) {
		throw new $TypeError('RegExp.prototype.flags getter called on non-object');
	}
	var result = '';
	if (this.hasIndices) {
		result += 'd';
	}
	if (this.global) {
		result += 'g';
	}
	if (this.ignoreCase) {
		result += 'i';
	}
	if (this.multiline) {
		result += 'm';
	}
	if (this.dotAll) {
		result += 's';
	}
	if (this.unicode) {
		result += 'u';
	}
	if (this.sticky) {
		result += 'y';
	}
	return result;
};

/***/ }),
/* 550 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var implementation = __webpack_require__(549);

var supportsDescriptors = __webpack_require__(130).supportsDescriptors;
var $gOPD = Object.getOwnPropertyDescriptor;

module.exports = function getPolyfill() {
	if (supportsDescriptors && (/a/mig).flags === 'gim') {
		var descriptor = $gOPD(RegExp.prototype, 'flags');
		if (descriptor && typeof descriptor.get === 'function' && typeof (/a/).dotAll === 'boolean') {
			return descriptor.get;
		}
	}
	return implementation;
};

/***/ }),
/* 551 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var randomByte = __webpack_require__(1448);

function encode(lookup, number) {
    var loopCounter = 0;
    var done;

var str = '';

while (!done) {
        str = str + lookup( ( (number >> (4 * loopCounter)) & 0x0f ) | randomByte() );
        done = number < (Math.pow(16, loopCounter + 1 ) );
        loopCounter++;
    }
    return str;
}

module.exports = encode;

/***/ }),
/* 552 */
/***/ (function(module, exports, __webpack_require__) {

// style-loader: Adds some css to the DOM by adding a <style> tag

// load the styles
var content = __webpack_require__(841);
if(typeof content === 'string') content = [[module.i, content, '']];
// add the styles to the DOM
var update = __webpack_require__(342)(content, {});
if(content.locals) module.exports = content.locals;
// Hot Module Replacement
if(false) {
	// When the styles change, update the <style> tags
	if(!content.locals) {
		module.hot.accept("!!../../../node_modules/css-loader/index.js!./postsLoader.css", function() {
			var newContent = require("!!../../../node_modules/css-loader/index.js!./postsLoader.css");
			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
			update(newContent);
		});
	}
	// When the module is disposed, remove the <style> tags
	module.hot.dispose(function() { update(); });
}

/***/ }),
/* 553 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_RESULT__;// TinyColor v1.4.2
// https://github.com/bgrins/TinyColor
// Brian Grinstead, MIT License

(function(Math) {

var trimLeft = /^\s+/,
    trimRight = /\s+$/,
    tinyCounter = 0,
    mathRound = Math.round,
    mathMin = Math.min,
    mathMax = Math.max,
    mathRandom = Math.random;

function tinycolor (color, opts) {

color = (color) ? color : '';
    opts = opts || { };

// If input is already a tinycolor, return itself
    if (color instanceof tinycolor) {
       return color;
    }
    // If we are called as a function, call using new instead
    if (!(this instanceof tinycolor)) {
        return new tinycolor(color, opts);
    }

var rgb = inputToRGB(color);
    this._originalInput = color,
    this._r = rgb.r,
    this._g = rgb.g,
    this._b = rgb.b,
    this._a = rgb.a,
    this._roundA = mathRound(100*this._a) / 100,
    this._format = opts.format || rgb.format;
    this._gradientType = opts.gradientType;

// Don't let the range of [0,255] come back in [0,1].
    // Potentially lose a little bit of precision here, but will fix issues where
    // .5 gets interpreted as half of the total, instead of half of 1
    // If it was supposed to be 128, this was already taken care of by `inputToRgb`
    if (this._r < 1) { this._r = mathRound(this._r); }
    if (this._g < 1) { this._g = mathRound(this._g); }
    if (this._b < 1) { this._b = mathRound(this._b); }

this._ok = rgb.ok;
    this._tc_id = tinyCounter++;
}

tinycolor.prototype = {
    isDark: function() {
        return this.getBrightness() < 128;
    },
    isLight: function() {
        return !this.isDark();
    },
    isValid: function() {
        return this._ok;
    },
    getOriginalInput: function() {
      return this._originalInput;
    },
    getFormat: function() {
        return this._format;
    },
    getAlpha: function() {
        return this._a;
    },
    getBrightness: function() {
        //http://www.w3.org/TR/AERT#color-contrast
        var rgb = this.toRgb();
        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
    },
    getLuminance: function() {
        //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
        var rgb = this.toRgb();
        var RsRGB, GsRGB, BsRGB, R, G, B;
        RsRGB = rgb.r/255;
        GsRGB = rgb.g/255;
        BsRGB = rgb.b/255;

if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);}
        if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);}
        if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);}
        return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);
    },
    setAlpha: function(value) {
        this._a = boundAlpha(value);
        this._roundA = mathRound(100*this._a) / 100;
        return this;
    },
    toHsv: function() {
        var hsv = rgbToHsv(this._r, this._g, this._b);
        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
    },
    toHsvString: function() {
        var hsv = rgbToHsv(this._r, this._g, this._b);
        var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);
        return (this._a == 1) ?
          "hsv("  + h + ", " + s + "%, " + v + "%)" :
          "hsva(" + h + ", " + s + "%, " + v + "%, "+ this._roundA + ")";
    },
    toHsl: function() {
        var hsl = rgbToHsl(this._r, this._g, this._b);
        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };
    },
    toHslString: function() {
        var hsl = rgbToHsl(this._r, this._g, this._b);
        var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);
        return (this._a == 1) ?
          "hsl("  + h + ", " + s + "%, " + l + "%)" :
          "hsla(" + h + ", " + s + "%, " + l + "%, "+ this._roundA + ")";
    },
    toHex: function(allow3Char) {
        return rgbToHex(this._r, this._g, this._b, allow3Char);
    },
    toHexString: function(allow3Char) {
        return '#' + this.toHex(allow3Char);
    },
    toHex8: function(allow4Char) {
        return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
    },
    toHex8String: function(allow4Char) {
        return '#' + this.toHex8(allow4Char);
    },
    toRgb: function() {
        return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };
    },
    toRgbString: function() {
        return (this._a == 1) ?
          "rgb("  + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" :
          "rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")";
    },
    toPercentageRgb: function() {
        return { r: mathRound(bound01(this._r, 255) * 100) + "%", g: mathRound(bound01(this._g, 255) * 100) + "%", b: mathRound(bound01(this._b, 255) * 100) + "%", a: this._a };
    },
    toPercentageRgbString: function() {
        return (this._a == 1) ?
          "rgb("  + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" :
          "rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")";
    },
    toName: function() {
        if (this._a === 0) {
            return "transparent";
        }

if (this._a < 1) {
            return false;
        }

return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
    },
    toFilter: function(secondColor) {
        var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a);
        var secondHex8String = hex8String;
        var gradientType = this._gradientType ? "GradientType = 1, " : "";

if (secondColor) {
            var s = tinycolor(secondColor);
            secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a);
        }

return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr="+hex8String+",endColorstr="+secondHex8String+")";
    },
    toString: function(format) {
        var formatSet = !!format;
        format = format || this._format;

var formattedString = false;
        var hasAlpha = this._a < 1 && this._a >= 0;
        var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name");

if (needsAlphaFormat) {
            // Special case for "transparent", all other non-alpha formats
            // will return rgba when there is transparency.
            if (format === "name" && this._a === 0) {
                return this.toName();
            }
            return this.toRgbString();
        }
        if (format === "rgb") {
            formattedString = this.toRgbString();
        }
        if (format === "prgb") {
            formattedString = this.toPercentageRgbString();
        }
        if (format === "hex" || format === "hex6") {
            formattedString = this.toHexString();
        }
        if (format === "hex3") {
            formattedString = this.toHexString(true);
        }
        if (format === "hex4") {
            formattedString = this.toHex8String(true);
        }
        if (format === "hex8") {
            formattedString = this.toHex8String();
        }
        if (format === "name") {
            formattedString = this.toName();
        }
        if (format === "hsl") {
            formattedString = this.toHslString();
        }
        if (format === "hsv") {
            formattedString = this.toHsvString();
        }

return formattedString || this.toHexString();
    },
    clone: function() {
        return tinycolor(this.toString());
    },

_applyModification: function(fn, args) {
        var color = fn.apply(null, [this].concat([].slice.call(args)));
        this._r = color._r;
        this._g = color._g;
        this._b = color._b;
        this.setAlpha(color._a);
        return this;
    },
    lighten: function() {
        return this._applyModification(lighten, arguments);
    },
    brighten: function() {
        return this._applyModification(brighten, arguments);
    },
    darken: function() {
        return this._applyModification(darken, arguments);
    },
    desaturate: function() {
        return this._applyModification(desaturate, arguments);
    },
    saturate: function() {
        return this._applyModification(saturate, arguments);
    },
    greyscale: function() {
        return this._applyModification(greyscale, arguments);
    },
    spin: function() {
        return this._applyModification(spin, arguments);
    },

_applyCombination: function(fn, args) {
        return fn.apply(null, [this].concat([].slice.call(args)));
    },
    analogous: function() {
        return this._applyCombination(analogous, arguments);
    },
    complement: function() {
        return this._applyCombination(complement, arguments);
    },
    monochromatic: function() {
        return this._applyCombination(monochromatic, arguments);
    },
    splitcomplement: function() {
        return this._applyCombination(splitcomplement, arguments);
    },
    triad: function() {
        return this._applyCombination(triad, arguments);
    },
    tetrad: function() {
        return this._applyCombination(tetrad, arguments);
    }
};

// If input is an object, force 1 into "1.0" to handle ratios properly
// String input requires "1.0" as input, so 1 will be treated as 1
tinycolor.fromRatio = function(color, opts) {
    if (typeof color == "object") {
        var newColor = {};
        for (var i in color) {
            if (color.hasOwnProperty(i)) {
                if (i === "a") {
                    newColor[i] = color[i];
                }
                else {
                    newColor[i] = convertToPercentage(color[i]);
                }
            }
        }
        color = newColor;
    }

return tinycolor(color, opts);
};

// Given a string or object, convert that input to RGB
// Possible string inputs:
//
//     "red"
//     "#f00" or "f00"
//     "#ff0000" or "ff0000"
//     "#ff000000" or "ff000000"
//     "rgb 255 0 0" or "rgb (255, 0, 0)"
//     "rgb 1.0 0 0" or "rgb (1, 0, 0)"
//     "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
//     "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
//     "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
//     "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
//     "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
//
function inputToRGB(color) {

var rgb = { r: 0, g: 0, b: 0 };
    var a = 1;
    var s = null;
    var v = null;
    var l = null;
    var ok = false;
    var format = false;

if (typeof color == "string") {
        color = stringInputToObject(color);
    }

if (typeof color == "object") {
        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
            rgb = rgbToRgb(color.r, color.g, color.b);
            ok = true;
            format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
        }
        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
            s = convertToPercentage(color.s);
            v = convertToPercentage(color.v);
            rgb = hsvToRgb(color.h, s, v);
            ok = true;
            format = "hsv";
        }
        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
            s = convertToPercentage(color.s);
            l = convertToPercentage(color.l);
            rgb = hslToRgb(color.h, s, l);
            ok = true;
            format = "hsl";
        }

if (color.hasOwnProperty("a")) {
            a = color.a;
        }
    }

a = boundAlpha(a);

return {
        ok: ok,
        format: color.format || format,
        r: mathMin(255, mathMax(rgb.r, 0)),
        g: mathMin(255, mathMax(rgb.g, 0)),
        b: mathMin(255, mathMax(rgb.b, 0)),
        a: a
    };
}

// Conversion Functions
// --------------------

// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>

// `rgbToRgb`
// Handle bounds / percentage checking to conform to CSS color spec
// <http://www.w3.org/TR/css3-color/>
// *Assumes:* r, g, b in [0, 255] or [0, 1]
// *Returns:* { r, g, b } in [0, 255]
function rgbToRgb(r, g, b){
    return {
        r: bound01(r, 255) * 255,
        g: bound01(g, 255) * 255,
        b: bound01(b, 255) * 255
    };
}

// `rgbToHsl`
// Converts an RGB color value to HSL.
// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
// *Returns:* { h, s, l } in [0,1]
function rgbToHsl(r, g, b) {

r = bound01(r, 255);
    g = bound01(g, 255);
    b = bound01(b, 255);

var max = mathMax(r, g, b), min = mathMin(r, g, b);
    var h, s, l = (max + min) / 2;

if(max == min) {
        h = s = 0; // achromatic
    }
    else {
        var d = max - min;
        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
        switch(max) {
            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
            case g: h = (b - r) / d + 2; break;
            case b: h = (r - g) / d + 4; break;
        }

h /= 6;
    }

return { h: h, s: s, l: l };
}

// `hslToRgb`
// Converts an HSL color value to RGB.
// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
// *Returns:* { r, g, b } in the set [0, 255]
function hslToRgb(h, s, l) {
    var r, g, b;

h = bound01(h, 360);
    s = bound01(s, 100);
    l = bound01(l, 100);

function hue2rgb(p, q, t) {
        if(t < 0) t += 1;
        if(t > 1) t -= 1;
        if(t < 1/6) return p + (q - p) * 6 * t;
        if(t < 1/2) return q;
        if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;
        return p;
    }

if(s === 0) {
        r = g = b = l; // achromatic
    }
    else {
        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
        var p = 2 * l - q;
        r = hue2rgb(p, q, h + 1/3);
        g = hue2rgb(p, q, h);
        b = hue2rgb(p, q, h - 1/3);
    }

return { r: r * 255, g: g * 255, b: b * 255 };
}

// `rgbToHsv`
// Converts an RGB color value to HSV
// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
// *Returns:* { h, s, v } in [0,1]
function rgbToHsv(r, g, b) {

r = bound01(r, 255);
    g = bound01(g, 255);
    b = bound01(b, 255);

var max = mathMax(r, g, b), min = mathMin(r, g, b);
    var h, s, v = max;

var d = max - min;
    s = max === 0 ? 0 : d / max;

if(max == min) {
        h = 0; // achromatic
    }
    else {
        switch(max) {
            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
            case g: h = (b - r) / d + 2; break;
            case b: h = (r - g) / d + 4; break;
        }
        h /= 6;
    }
    return { h: h, s: s, v: v };
}

// `hsvToRgb`
// Converts an HSV color value to RGB.
// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
// *Returns:* { r, g, b } in the set [0, 255]
 function hsvToRgb(h, s, v) {

h = bound01(h, 360) * 6;
    s = bound01(s, 100);
    v = bound01(v, 100);

var i = Math.floor(h),
        f = h - i,
        p = v * (1 - s),
        q = v * (1 - f * s),
        t = v * (1 - (1 - f) * s),
        mod = i % 6,
        r = [v, q, p, p, t, v][mod],
        g = [t, v, v, q, p, p][mod],
        b = [p, p, t, v, v, q][mod];

return { r: r * 255, g: g * 255, b: b * 255 };
}

// `rgbToHex`
// Converts an RGB color to hex
// Assumes r, g, and b are contained in the set [0, 255]
// Returns a 3 or 6 character hex
function rgbToHex(r, g, b, allow3Char) {

var hex = [
        pad2(mathRound(r).toString(16)),
        pad2(mathRound(g).toString(16)),
        pad2(mathRound(b).toString(16))
    ];

// Return a 3 character hex if possible
    if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {
        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
    }

return hex.join("");
}

// `rgbaToHex`
// Converts an RGBA color plus alpha transparency to hex
// Assumes r, g, b are contained in the set [0, 255] and
// a in [0, 1]. Returns a 4 or 8 character rgba hex
function rgbaToHex(r, g, b, a, allow4Char) {

var hex = [
        pad2(mathRound(r).toString(16)),
        pad2(mathRound(g).toString(16)),
        pad2(mathRound(b).toString(16)),
        pad2(convertDecimalToHex(a))
    ];

// Return a 4 character hex if possible
    if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {
        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
    }

return hex.join("");
}

// `rgbaToArgbHex`
// Converts an RGBA color to an ARGB Hex8 string
// Rarely used, but required for "toFilter()"
function rgbaToArgbHex(r, g, b, a) {

var hex = [
        pad2(convertDecimalToHex(a)),
        pad2(mathRound(r).toString(16)),
        pad2(mathRound(g).toString(16)),
        pad2(mathRound(b).toString(16))
    ];

return hex.join("");
}

// `equals`
// Can be called with any tinycolor input
tinycolor.equals = function (color1, color2) {
    if (!color1 || !color2) { return false; }
    return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
};

tinycolor.random = function() {
    return tinycolor.fromRatio({
        r: mathRandom(),
        g: mathRandom(),
        b: mathRandom()
    });
};

// Modification Functions
// ----------------------
// Thanks to less.js for some of the basics here
// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>

function desaturate(color, amount) {
    amount = (amount === 0) ? 0 : (amount || 10);
    var hsl = tinycolor(color).toHsl();
    hsl.s -= amount / 100;
    hsl.s = clamp01(hsl.s);
    return tinycolor(hsl);
}

function saturate(color, amount) {
    amount = (amount === 0) ? 0 : (amount || 10);
    var hsl = tinycolor(color).toHsl();
    hsl.s += amount / 100;
    hsl.s = clamp01(hsl.s);
    return tinycolor(hsl);
}

function greyscale(color) {
    return tinycolor(color).desaturate(100);
}

function lighten (color, amount) {
    amount = (amount === 0) ? 0 : (amount || 10);
    var hsl = tinycolor(color).toHsl();
    hsl.l += amount / 100;
    hsl.l = clamp01(hsl.l);
    return tinycolor(hsl);
}

function brighten(color, amount) {
    amount = (amount === 0) ? 0 : (amount || 10);
    var rgb = tinycolor(color).toRgb();
    rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));
    rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));
    rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));
    return tinycolor(rgb);
}

function darken (color, amount) {
    amount = (amount === 0) ? 0 : (amount || 10);
    var hsl = tinycolor(color).toHsl();
    hsl.l -= amount / 100;
    hsl.l = clamp01(hsl.l);
    return tinycolor(hsl);
}

// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
// Values outside of this range will be wrapped into this range.
function spin(color, amount) {
    var hsl = tinycolor(color).toHsl();
    var hue = (hsl.h + amount) % 360;
    hsl.h = hue < 0 ? 360 + hue : hue;
    return tinycolor(hsl);
}

// Combination Functions
// ---------------------
// Thanks to jQuery xColor for some of the ideas behind these
// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>

function complement(color) {
    var hsl = tinycolor(color).toHsl();
    hsl.h = (hsl.h + 180) % 360;
    return tinycolor(hsl);
}

function analogous(color, results, slices) {
    results = results || 6;
    slices = slices || 30;

var hsl = tinycolor(color).toHsl();
    var part = 360 / slices;
    var ret = [tinycolor(color)];

for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {
        hsl.h = (hsl.h + part) % 360;
        ret.push(tinycolor(hsl));
    }
    return ret;
}

function monochromatic(color, results) {
    results = results || 6;
    var hsv = tinycolor(color).toHsv();
    var h = hsv.h, s = hsv.s, v = hsv.v;
    var ret = [];
    var modification = 1 / results;

while (results--) {
        ret.push(tinycolor({ h: h, s: s, v: v}));
        v = (v + modification) % 1;
    }

return ret;
}

// Utility Functions
// ---------------------

tinycolor.mix = function(color1, color2, amount) {
    amount = (amount === 0) ? 0 : (amount || 50);

var rgb1 = tinycolor(color1).toRgb();
    var rgb2 = tinycolor(color2).toRgb();

var p = amount / 100;

var rgba = {
        r: ((rgb2.r - rgb1.r) * p) + rgb1.r,
        g: ((rgb2.g - rgb1.g) * p) + rgb1.g,
        b: ((rgb2.b - rgb1.b) * p) + rgb1.b,
        a: ((rgb2.a - rgb1.a) * p) + rgb1.a
    };

return tinycolor(rgba);
};

// Readability Functions
// ---------------------
// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)

// `contrast`
// Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
tinycolor.readability = function(color1, color2) {
    var c1 = tinycolor(color1);
    var c2 = tinycolor(color2);
    return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05);
};

// `isReadable`
// Ensure that foreground and background color combinations meet WCAG2 guidelines.
// The third argument is an optional Object.
//      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
//      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
// If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.

// *Example*
//    tinycolor.isReadable("#000", "#111") => false
//    tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false
tinycolor.isReadable = function(color1, color2, wcag2) {
    var readability = tinycolor.readability(color1, color2);
    var wcag2Parms, out;

out = false;

wcag2Parms = validateWCAG2Parms(wcag2);
    switch (wcag2Parms.level + wcag2Parms.size) {
        case "AAsmall":
        case "AAAlarge":
            out = readability >= 4.5;
            break;
        case "AAlarge":
            out = readability >= 3;
            break;
        case "AAAsmall":
            out = readability >= 7;
            break;
    }
    return out;

};

// `mostReadable`
// Given a base color and a list of possible foreground or background
// colors for that base, returns the most readable color.
// Optionally returns Black or White if the most readable color is unreadable.
// *Example*
//    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:false}).toHexString(); // "#112255"
//    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString();  // "#ffffff"
//    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3"
//    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff"
tinycolor.mostReadable = function(baseColor, colorList, args) {
    var bestColor = null;
    var bestScore = 0;
    var readability;
    var includeFallbackColors, level, size ;
    args = args || {};
    includeFallbackColors = args.includeFallbackColors ;
    level = args.level;
    size = args.size;

for (var i= 0; i < colorList.length ; i++) {
        readability = tinycolor.readability(baseColor, colorList[i]);
        if (readability > bestScore) {
            bestScore = readability;
            bestColor = tinycolor(colorList[i]);
        }
    }

if (tinycolor.isReadable(baseColor, bestColor, {"level":level,"size":size}) || !includeFallbackColors) {
        return bestColor;
    }
    else {
        args.includeFallbackColors=false;
        return tinycolor.mostReadable(baseColor,["#fff", "#000"],args);
    }
};

// Big List of Colors
// ------------------
// <http://www.w3.org/TR/css3-color/#svg-color>
var names = tinycolor.names = {
    aliceblue: "f0f8ff",
    antiquewhite: "faebd7",
    aqua: "0ff",
    aquamarine: "7fffd4",
    azure: "f0ffff",
    beige: "f5f5dc",
    bisque: "ffe4c4",
    black: "000",
    blanchedalmond: "ffebcd",
    blue: "00f",
    blueviolet: "8a2be2",
    brown: "a52a2a",
    burlywood: "deb887",
    burntsienna: "ea7e5d",
    cadetblue: "5f9ea0",
    chartreuse: "7fff00",
    chocolate: "d2691e",
    coral: "ff7f50",
    cornflowerblue: "6495ed",
    cornsilk: "fff8dc",
    crimson: "dc143c",
    cyan: "0ff",
    darkblue: "00008b",
    darkcyan: "008b8b",
    darkgoldenrod: "b8860b",
    darkgray: "a9a9a9",
    darkgreen: "006400",
    darkgrey: "a9a9a9",
    darkkhaki: "bdb76b",
    darkmagenta: "8b008b",
    darkolivegreen: "556b2f",
    darkorange: "ff8c00",
    darkorchid: "9932cc",
    darkred: "8b0000",
    darksalmon: "e9967a",
    darkseagreen: "8fbc8f",
    darkslateblue: "483d8b",
    darkslategray: "2f4f4f",
    darkslategrey: "2f4f4f",
    darkturquoise: "00ced1",
    darkviolet: "9400d3",
    deeppink: "ff1493",
    deepskyblue: "00bfff",
    dimgray: "696969",
    dimgrey: "696969",
    dodgerblue: "1e90ff",
    firebrick: "b22222",
    floralwhite: "fffaf0",
    forestgreen: "228b22",
    fuchsia: "f0f",
    gainsboro: "dcdcdc",
    ghostwhite: "f8f8ff",
    gold: "ffd700",
    goldenrod: "daa520",
    gray: "808080",
    green: "008000",
    greenyellow: "adff2f",
    grey: "808080",
    honeydew: "f0fff0",
    hotpink: "ff69b4",
    indianred: "cd5c5c",
    indigo: "4b0082",
    ivory: "fffff0",
    khaki: "f0e68c",
    lavender: "e6e6fa",
    lavenderblush: "fff0f5",
    lawngreen: "7cfc00",
    lemonchiffon: "fffacd",
    lightblue: "add8e6",
    lightcoral: "f08080",
    lightcyan: "e0ffff",
    lightgoldenrodyellow: "fafad2",
    lightgray: "d3d3d3",
    lightgreen: "90ee90",
    lightgrey: "d3d3d3",
    lightpink: "ffb6c1",
    lightsalmon: "ffa07a",
    lightseagreen: "20b2aa",
    lightskyblue: "87cefa",
    lightslategray: "789",
    lightslategrey: "789",
    lightsteelblue: "b0c4de",
    lightyellow: "ffffe0",
    lime: "0f0",
    limegreen: "32cd32",
    linen: "faf0e6",
    magenta: "f0f",
    maroon: "800000",
    mediumaquamarine: "66cdaa",
    mediumblue: "0000cd",
    mediumorchid: "ba55d3",
    mediumpurple: "9370db",
    mediumseagreen: "3cb371",
    mediumslateblue: "7b68ee",
    mediumspringgreen: "00fa9a",
    mediumturquoise: "48d1cc",
    mediumvioletred: "c71585",
    midnightblue: "191970",
    mintcream: "f5fffa",
    mistyrose: "ffe4e1",
    moccasin: "ffe4b5",
    navajowhite: "ffdead",
    navy: "000080",
    oldlace: "fdf5e6",
    olive: "808000",
    olivedrab: "6b8e23",
    orange: "ffa500",
    orangered: "ff4500",
    orchid: "da70d6",
    palegoldenrod: "eee8aa",
    palegreen: "98fb98",
    paleturquoise: "afeeee",
    palevioletred: "db7093",
    papayawhip: "ffefd5",
    peachpuff: "ffdab9",
    peru: "cd853f",
    pink: "ffc0cb",
    plum: "dda0dd",
    powderblue: "b0e0e6",
    purple: "800080",
    rebeccapurple: "663399",
    red: "f00",
    rosybrown: "bc8f8f",
    royalblue: "4169e1",
    saddlebrown: "8b4513",
    salmon: "fa8072",
    sandybrown: "f4a460",
    seagreen: "2e8b57",
    seashell: "fff5ee",
    sienna: "a0522d",
    silver: "c0c0c0",
    skyblue: "87ceeb",
    slateblue: "6a5acd",
    slategray: "708090",
    slategrey: "708090",
    snow: "fffafa",
    springgreen: "00ff7f",
    steelblue: "4682b4",
    tan: "d2b48c",
    teal: "008080",
    thistle: "d8bfd8",
    tomato: "ff6347",
    turquoise: "40e0d0",
    violet: "ee82ee",
    wheat: "f5deb3",
    white: "fff",
    whitesmoke: "f5f5f5",
    yellow: "ff0",
    yellowgreen: "9acd32"
};

// Make it easy to access colors via `hexNames[hex]`
var hexNames = tinycolor.hexNames = flip(names);

// Utilities
// ---------

// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
function flip(o) {
    var flipped = { };
    for (var i in o) {
        if (o.hasOwnProperty(i)) {
            flipped[o[i]] = i;
        }
    }
    return flipped;
}

// Return a valid alpha value [0,1] with all invalid values being set to 1
function boundAlpha(a) {
    a = parseFloat(a);

if (isNaN(a) || a < 0 || a > 1) {
        a = 1;
    }

return a;
}

// Take input from [0, n] and return it as [0, 1]
function bound01(n, max) {
    if (isOnePointZero(n)) { n = "100%"; }

var processPercent = isPercentage(n);
    n = mathMin(max, mathMax(0, parseFloat(n)));

// Automatically convert percentage into number
    if (processPercent) {
        n = parseInt(n * max, 10) / 100;
    }

// Handle floating point rounding errors
    if ((Math.abs(n - max) < 0.000001)) {
        return 1;
    }

// Convert into [0, 1] range if it isn't already
    return (n % max) / parseFloat(max);
}

// Force a number between 0 and 1
function clamp01(val) {
    return mathMin(1, mathMax(0, val));
}

// Parse a base-16 hex value into a base-10 integer
function parseIntFromHex(val) {
    return parseInt(val, 16);
}

// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
function isOnePointZero(n) {
    return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1;
}

// Check to see if string passed in is a percentage
function isPercentage(n) {
    return typeof n === "string" && n.indexOf('%') != -1;
}

// Force a hex value to have 2 characters
function pad2(c) {
    return c.length == 1 ? '0' + c : '' + c;
}

// Replace a decimal with it's percentage value
function convertToPercentage(n) {
    if (n <= 1) {
        n = (n * 100) + "%";
    }

return n;
}

// Converts a decimal to a hex value
function convertDecimalToHex(d) {
    return Math.round(parseFloat(d) * 255).toString(16);
}
// Converts a hex value to a decimal
function convertHexToDecimal(h) {
    return (parseIntFromHex(h) / 255);
}

var matchers = (function() {

// <http://www.w3.org/TR/css3-values/#integers>
    var CSS_INTEGER = "[-\\+]?\\d+%?";

// <http://www.w3.org/TR/css3-values/#number-value>
    var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";

// Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
    var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";

// Actual matching.
    // Parentheses and commas are optional, but not required.
    // Whitespace can take the place of commas or opening paren
    var PERMISSIVE_MATCH3 = "[\\s|\$]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\$?";
    var PERMISSIVE_MATCH4 = "[\\s|\$]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\$?";

return {
        CSS_UNIT: new RegExp(CSS_UNIT),
        rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
        rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
        hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
        hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
        hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
        hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
        hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
        hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
        hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
        hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
    };
})();

// `isValidCSSUnit`
// Take in a single string / number and check to see if it looks like a CSS unit
// (see `matchers` above for definition).
function isValidCSSUnit(color) {
    return !!matchers.CSS_UNIT.exec(color);
}

// `stringInputToObject`
// Permissive string parsing.  Take in a number of formats, and output an object
// based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
function stringInputToObject(color) {

color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();
    var named = false;
    if (names[color]) {
        color = names[color];
        named = true;
    }
    else if (color == 'transparent') {
        return { r: 0, g: 0, b: 0, a: 0, format: "name" };
    }

// Try to match string input using regular expressions.
    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
    // Just return an object and let the conversion functions handle that.
    // This way the result will be the same whether the tinycolor is initialized with string or object.
    var match;
    if ((match = matchers.rgb.exec(color))) {
        return { r: match[1], g: match[2], b: match[3] };
    }
    if ((match = matchers.rgba.exec(color))) {
        return { r: match[1], g: match[2], b: match[3], a: match[4] };
    }
    if ((match = matchers.hsl.exec(color))) {
        return { h: match[1], s: match[2], l: match[3] };
    }
    if ((match = matchers.hsla.exec(color))) {
        return { h: match[1], s: match[2], l: match[3], a: match[4] };
    }
    if ((match = matchers.hsv.exec(color))) {
        return { h: match[1], s: match[2], v: match[3] };
    }
    if ((match = matchers.hsva.exec(color))) {
        return { h: match[1], s: match[2], v: match[3], a: match[4] };
    }
    if ((match = matchers.hex8.exec(color))) {
        return {
            r: parseIntFromHex(match[1]),
            g: parseIntFromHex(match[2]),
            b: parseIntFromHex(match[3]),
            a: convertHexToDecimal(match[4]),
            format: named ? "name" : "hex8"
        };
    }
    if ((match = matchers.hex6.exec(color))) {
        return {
            r: parseIntFromHex(match[1]),
            g: parseIntFromHex(match[2]),
            b: parseIntFromHex(match[3]),
            format: named ? "name" : "hex"
        };
    }
    if ((match = matchers.hex4.exec(color))) {
        return {
            r: parseIntFromHex(match[1] + '' + match[1]),
            g: parseIntFromHex(match[2] + '' + match[2]),
            b: parseIntFromHex(match[3] + '' + match[3]),
            a: convertHexToDecimal(match[4] + '' + match[4]),
            format: named ? "name" : "hex8"
        };
    }
    if ((match = matchers.hex3.exec(color))) {
        return {
            r: parseIntFromHex(match[1] + '' + match[1]),
            g: parseIntFromHex(match[2] + '' + match[2]),
            b: parseIntFromHex(match[3] + '' + match[3]),
            format: named ? "name" : "hex"
        };
    }

return false;
}

// Node: Export function
if (typeof module !== "undefined" && module.exports) {
    module.exports = tinycolor;
}
// AMD/requirejs: Define the module
else if (true) {
    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {return tinycolor;}.call(exports, __webpack_require__, exports, module),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
}
// Browser: Expose to window
else {
    window.tinycolor = tinycolor;
}

})(Math);

/***/ }),
/* 554 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var ReactDOM = __webpack_require__(7),
    App = __webpack_require__(630),
    store = __webpack_require__(11);
store.subscribe(init);
function init() {
    var stateData = store.getState();
    ReactDOM.render(React.createElement(App, { state: stateData }), document.getElementById('root'));
}
init();
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 555 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {/**
 *
 *
 * @author Jerry Bendy <jerry@icewingcc.com>
 * @licence MIT
 *
 */

(function(self) {
    'use strict';

var nativeURLSearchParams = self.URLSearchParams ? self.URLSearchParams : null,
        isSupportObjectConstructor = nativeURLSearchParams && (new nativeURLSearchParams({a: 1})).toString() === 'a=1',
        // There is a bug in safari 10.1 (and earlier) that incorrectly decodes `%2B` as an empty space and not a plus.
        decodesPlusesCorrectly = nativeURLSearchParams && (new nativeURLSearchParams('s=%2B').get('s') === '+'),
        __URLSearchParams__ = "__URLSearchParams__",
        prototype = URLSearchParamsPolyfill.prototype,
        iterable = !!(self.Symbol && self.Symbol.iterator);

if (nativeURLSearchParams && isSupportObjectConstructor && decodesPlusesCorrectly) {
        return;
    }

/**
     * Make a URLSearchParams instance
     *
     * @param {object|string|URLSearchParams} search
     * @constructor
     */
    function URLSearchParamsPolyfill(search) {
        search = search || "";

// support construct object with another URLSearchParams instance
        if (search instanceof URLSearchParams || search instanceof URLSearchParamsPolyfill) {
            search = search.toString();
        }
        this [__URLSearchParams__] = parseToDict(search);
    }

/**
     * Appends a specified key/value pair as a new search parameter.
     *
     * @param {string} name
     * @param {string} value
     */
    prototype.append = function(name, value) {
        appendTo(this [__URLSearchParams__], name, value);
    };

/**
     * Deletes the given search parameter, and its associated value,
     * from the list of all search parameters.
     *
     * @param {string} name
     */
    prototype.delete = function(name) {
        delete this [__URLSearchParams__] [name];
    };

/**
     * Returns the first value associated to the given search parameter.
     *
     * @param {string} name
     * @returns {string|null}
     */
    prototype.get = function(name) {
        var dict = this [__URLSearchParams__];
        return name in dict ? dict[name][0] : null;
    };

/**
     * Returns all the values association with a given search parameter.
     *
     * @param {string} name
     * @returns {Array}
     */
    prototype.getAll = function(name) {
        var dict = this [__URLSearchParams__];
        return name in dict ? dict [name].slice(0) : [];
    };

/**
     * Returns a Boolean indicating if such a search parameter exists.
     *
     * @param {string} name
     * @returns {boolean}
     */
    prototype.has = function(name) {
        return name in this [__URLSearchParams__];
    };

/**
     * Sets the value associated to a given search parameter to
     * the given value. If there were several values, delete the
     * others.
     *
     * @param {string} name
     * @param {string} value
     */
    prototype.set = function set(name, value) {
        this [__URLSearchParams__][name] = ['' + value];
    };

/**
     * Returns a string containg a query string suitable for use in a URL.
     *
     * @returns {string}
     */
    prototype.toString = function() {
        var dict = this[__URLSearchParams__], query = [], i, key, name, value;
        for (key in dict) {
            name = encode(key);
            for (i = 0, value = dict[key]; i < value.length; i++) {
                query.push(name + '=' + encode(value[i]));
            }
        }
        return query.join('&');
    };

// There is a bug in Safari 10.1 and `Proxy`ing it is not enough.
    var forSureUsePolyfill = !decodesPlusesCorrectly;
    var useProxy = (!forSureUsePolyfill && nativeURLSearchParams && !isSupportObjectConstructor && self.Proxy)
    /*
     * Apply polifill to global object and append other prototype into it
     */
    self.URLSearchParams = useProxy ?
        // Safari 10.0 doesn't support Proxy, so it won't extend URLSearchParams on safari 10.0
        new Proxy(nativeURLSearchParams, {
            construct: function(target, args) {
                return new target((new URLSearchParamsPolyfill(args[0]).toString()));
            }
        }) :
        URLSearchParamsPolyfill;

var USPProto = self.URLSearchParams.prototype;

USPProto.polyfill = true;

/**
     *
     * @param {function} callback
     * @param {object} thisArg
     */
    USPProto.forEach = USPProto.forEach || function(callback, thisArg) {
        var dict = parseToDict(this.toString());
        Object.getOwnPropertyNames(dict).forEach(function(name) {
            dict[name].forEach(function(value) {
                callback.call(thisArg, value, name, this);
            }, this);
        }, this);
    };

/**
     * Sort all name-value pairs
     */
    USPProto.sort = USPProto.sort || function() {
        var dict = parseToDict(this.toString()), keys = [], k, i, j;
        for (k in dict) {
            keys.push(k);
        }
        keys.sort();

for (i = 0; i < keys.length; i++) {
            this.delete(keys[i]);
        }
        for (i = 0; i < keys.length; i++) {
            var key = keys[i], values = dict[key];
            for (j = 0; j < values.length; j++) {
                this.append(key, values[j]);
            }
        }
    };

/**
     * Returns an iterator allowing to go through all keys of
     * the key/value pairs contained in this object.
     *
     * @returns {function}
     */
    USPProto.keys = USPProto.keys || function() {
        var items = [];
        this.forEach(function(item, name) {
            items.push(name);
        });
        return makeIterator(items);
    };

/**
     * Returns an iterator allowing to go through all values of
     * the key/value pairs contained in this object.
     *
     * @returns {function}
     */
    USPProto.values = USPProto.values || function() {
        var items = [];
        this.forEach(function(item) {
            items.push(item);
        });
        return makeIterator(items);
    };

/**
     * Returns an iterator allowing to go through all key/value
     * pairs contained in this object.
     *
     * @returns {function}
     */
    USPProto.entries = USPProto.entries || function() {
        var items = [];
        this.forEach(function(item, name) {
            items.push([name, item]);
        });
        return makeIterator(items);
    };

if (iterable) {
        USPProto[self.Symbol.iterator] = USPProto[self.Symbol.iterator] || USPProto.entries;
    }

function decode(str) {
        return decodeURIComponent(str.replace(/\+/g, ' '));
    }

if (iterable) {
            iterator[self.Symbol.iterator] = function() {
                return iterator;
            };
        }

return iterator;
    }

function parseToDict(search) {
        var dict = {};

if (typeof search === "object") {
            for (var key in search) {
                if (search.hasOwnProperty(key)) {
                    appendTo(dict, key, search[key])
                }
            }

} else {
            // remove first '?'
            if (search.indexOf("?") === 0) {
                search = search.slice(1);
            }

var pairs = search.split("&");
            for (var j = 0; j < pairs.length; j++) {
                var value = pairs [j],
                    index = value.indexOf('=');

if (-1 < index) {
                    appendTo(dict, decode(value.slice(0, index)), decode(value.slice(index + 1)));

} else {
                    if (value) {
                        appendTo(dict, decode(value), '');
                    }
                }
            }
        }

return dict;
    }

function appendTo(dict, name, value) {
        var val = typeof value === 'string' ? value : (
            value !== null && value !== undefined && typeof value.toString === 'function' ? value.toString() : JSON.stringify(value)
        )

if (name in dict) {
            dict[name].push(val);
        } else {
            dict[name] = [val];
        }
    }

})(typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : this));

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 556 */
/***/ (function(module, exports, __webpack_require__) {

/***/ }),
/* 557 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties__ = __webpack_require__(54);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__utils__ = __webpack_require__(558);

var twoToneColorPalette = {
    primaryColor: '#333',
    secondaryColor: '#E6E6E6'
};

var Icon = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default()(Icon, _React$Component);

function Icon() {
        __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default()(this, Icon);

return __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Icon.__proto__ || Object.getPrototypeOf(Icon)).apply(this, arguments));
    }

__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default()(Icon, [{
        key: 'render',
        value: function render() {
            var _extends2;

var _props = this.props,
                type = _props.type,
                className = _props.className,
                onClick = _props.onClick,
                style = _props.style,
                primaryColor = _props.primaryColor,
                secondaryColor = _props.secondaryColor,
                rest = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties___default()(_props, ['type', 'className', 'onClick', 'style', 'primaryColor', 'secondaryColor']);

for (var _len = arguments.length, icons = Array(_len), _key = 0; _key < _len; _key++) {
                icons[_key] = arguments[_key];
            }

icons.forEach(function (icon) {
                _this2.definitions.set(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils__["e" /* withSuffix */])(icon.name, icon.theme), icon);
            });
        }
    }, {
        key: 'clear',
        value: function clear() {
            this.definitions.clear();
        }
    }, {
        key: 'get',
        value: function get(key) {
            var colors = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : twoToneColorPalette;

if (key) {
                var target = this.definitions.get(key);
                if (target && typeof target.icon === 'function') {
                    target = __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, target, {
                        icon: target.icon(colors.primaryColor, colors.secondaryColor)
                    });
                }
                return target;
            }
        }
    }, {
        key: 'setTwoToneColors',
        value: function setTwoToneColors(_ref) {
            var primaryColor = _ref.primaryColor,
                secondaryColor = _ref.secondaryColor;

twoToneColorPalette.primaryColor = primaryColor;
            twoToneColorPalette.secondaryColor = secondaryColor || __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8__utils__["a" /* getSecondaryColor */])(primaryColor);
        }
    }, {
        key: 'getTwoToneColors',
        value: function getTwoToneColors() {
            return __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, twoToneColorPalette);
        }
    }]);

return Icon;
}(__WEBPACK_IMPORTED_MODULE_7_react__["Component"]);

Icon.displayName = 'IconReact';
Icon.definitions = new __WEBPACK_IMPORTED_MODULE_8__utils__["f" /* MiniMap */]();
/* harmony default export */ __webpack_exports__["a"] = (Icon);

/***/ }),
/* 558 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/* harmony export (immutable) */ __webpack_exports__["c"] = log;
/* harmony export (immutable) */ __webpack_exports__["b"] = isIconDefinition;
/* unused harmony export normalizeAttrs */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return MiniMap; });
/* harmony export (immutable) */ __webpack_exports__["d"] = generate;
/* harmony export (immutable) */ __webpack_exports__["a"] = getSecondaryColor;
/* harmony export (immutable) */ __webpack_exports__["e"] = withSuffix;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_ant_design_palettes__ = __webpack_require__(596);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_ant_design_palettes___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_ant_design_palettes__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_react__);

return Object.keys(attrs).reduce(function (acc, key) {
        var val = attrs[key];
        switch (key) {
            case 'class':
                acc.className = val;
                delete acc['class'];
                break;
            default:
                acc[key] = val;
        }
        return acc;
    }, {});
}
var MiniMap = function () {
    function MiniMap() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, MiniMap);

this.collection = {};
    }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(MiniMap, [{
        key: 'clear',
        value: function clear() {
            this.collection = {};
        }
    }, {
        key: 'delete',
        value: function _delete(key) {
            return delete this.collection[key];
        }
    }, {
        key: 'get',
        value: function get(key) {
            return this.collection[key];
        }
    }, {
        key: 'has',
        value: function has(key) {
            return Boolean(this.collection[key]);
        }
    }, {
        key: 'set',
        value: function set(key, value) {
            this.collection[key] = value;
            return this;
        }
    }, {
        key: 'size',
        get: function get() {
            return Object.keys(this.collection).length;
        }
    }]);

return MiniMap;
}();
function generate(node, key, rootProps) {
    if (!rootProps) {
        return __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](node.tag, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ key: key }, normalizeAttrs(node.attrs)), (node.children || []).map(function (child, index) {
            return generate(child, key + '-' + node.tag + '-' + index);
        }));
    }
    return __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](node.tag, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({
        key: key
    }, normalizeAttrs(node.attrs), rootProps), (node.children || []).map(function (child, index) {
        return generate(child, key + '-' + node.tag + '-' + index);
    }));
}
function getSecondaryColor(primaryColor) {
    // choose the second color
    return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3_ant_design_palettes__["generate"])(primaryColor)[0];
}
function withSuffix(name, theme) {
    switch (theme) {
        case 'fill':
            return name + '-fill';
        case 'outline':
            return name + '-o';
        case 'twotone':
            return name + '-twotone';
        default:
            throw new TypeError('Unknown theme type: ' + theme + ', name: ' + name);
    }
}
/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(1)))

/***/ }),
/* 559 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CheckCircleFill = {
    name: 'check-circle',
    theme: 'fill',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm193.5 301.7l-210.6 292a31.8 31.8 0 0 1-51.7 0L318.5 484.9c-3.8-5.3 0-12.7 6.5-12.7h46.9c10.2 0 19.9 4.9 25.9 13.3l71.2 98.8 157.2-218c6-8.3 15.6-13.3 25.9-13.3H699c6.5 0 10.3 7.4 6.5 12.7z'
                }
            }
        ]
    }
};
exports.default = CheckCircleFill;

/***/ }),
/* 560 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CloseCircleFill = {
    name: 'close-circle',
    theme: 'fill',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm165.4 618.2l-66-.3L512 563.4l-99.3 118.4-66.1.3c-4.4 0-8-3.5-8-8 0-1.9.7-3.7 1.9-5.2l130.1-155L340.5 359a8.32 8.32 0 0 1-1.9-5.2c0-4.4 3.6-8 8-8l66.1.3L512 464.6l99.3-118.4 66-.3c4.4 0 8 3.5 8 8 0 1.9-.7 3.7-1.9 5.2L553.5 514l130 155c1.2 1.5 1.9 3.3 1.9 5.2 0 4.4-3.6 8-8 8z'
                }
            }
        ]
    }
};
exports.default = CloseCircleFill;

/***/ }),
/* 561 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var ExclamationCircleFill = {
    name: 'exclamation-circle',
    theme: 'fill',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm-32 232c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V296zm32 440a48.01 48.01 0 0 1 0-96 48.01 48.01 0 0 1 0 96z'
                }
            }
        ]
    }
};
exports.default = ExclamationCircleFill;

/***/ }),
/* 562 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var InfoCircleFill = {
    name: 'info-circle',
    theme: 'fill',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm32 664c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V456c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272zm-32-344a48.01 48.01 0 0 1 0-96 48.01 48.01 0 0 1 0 96z'
                }
            }
        ]
    }
};
exports.default = InfoCircleFill;

/***/ }),
/* 563 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var StarFill = {
    name: 'star',
    theme: 'fill',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M908.1 353.1l-253.9-36.9L540.7 86.1c-3.1-6.3-8.2-11.4-14.5-14.5-15.8-7.8-35-1.3-42.9 14.5L369.8 316.2l-253.9 36.9c-7 1-13.4 4.3-18.3 9.3a32.05 32.05 0 0 0 .6 45.3l183.7 179.1-43.4 252.9a31.95 31.95 0 0 0 46.4 33.7L512 754l227.1 119.4c6.2 3.3 13.4 4.4 20.3 3.2 17.4-3 29.1-19.5 26.1-36.9l-43.4-252.9 183.7-179.1c5-4.9 8.3-11.3 9.3-18.3 2.7-17.5-9.5-33.7-27-36.3z'
                }
            }
        ]
    }
};
exports.default = StarFill;

/***/ }),
/* 564 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var BarsOutline = {
    name: 'bars',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '0 0 1024 1024' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M912 192H328c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h584c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8zm0 284H328c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h584c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8zm0 284H328c-4.4 0-8 3.6-8 8v56c0 4.4 3.6 8 8 8h584c4.4 0 8-3.6 8-8v-56c0-4.4-3.6-8-8-8zM104 228a56 56 0 1 0 112 0 56 56 0 1 0-112 0zm0 284a56 56 0 1 0 112 0 56 56 0 1 0-112 0zm0 284a56 56 0 1 0 112 0 56 56 0 1 0-112 0z'
                }
            }
        ]
    }
};
exports.default = BarsOutline;

/***/ }),
/* 565 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CalendarOutline = {
    name: 'calendar',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M880 184H712v-64c0-4.4-3.6-8-8-8h-56c-4.4 0-8 3.6-8 8v64H384v-64c0-4.4-3.6-8-8-8h-56c-4.4 0-8 3.6-8 8v64H144c-17.7 0-32 14.3-32 32v664c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V216c0-17.7-14.3-32-32-32zm-40 656H184V460h656v380zM184 392V256h128v48c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-48h256v48c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-48h128v136H184z'
                }
            }
        ]
    }
};
exports.default = CalendarOutline;

/***/ }),
/* 566 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CaretDownOutline = {
    name: 'caret-down',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '0 0 1024 1024' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M840.4 300H183.6c-19.7 0-30.7 20.8-18.5 35l328.4 380.8c9.4 10.9 27.5 10.9 37 0L858.9 335c12.2-14.2 1.2-35-18.5-35z'
                }
            }
        ]
    }
};
exports.default = CaretDownOutline;

/***/ }),
/* 567 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CaretUpOutline = {
    name: 'caret-up',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '0 0 1024 1024' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M858.9 689L530.5 308.2c-9.4-10.9-27.5-10.9-37 0L165.1 689c-12.2 14.2-1.2 35 18.5 35h656.8c19.7 0 30.7-20.8 18.5-35z'
                }
            }
        ]
    }
};
exports.default = CaretUpOutline;

/***/ }),
/* 568 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CheckCircleOutline = {
    name: 'check-circle',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M699 353h-46.9c-10.2 0-19.9 4.9-25.9 13.3L469 584.3l-71.2-98.8c-6-8.3-15.6-13.3-25.9-13.3H325c-6.5 0-10.3 7.4-6.5 12.7l124.6 172.8a31.8 31.8 0 0 0 51.7 0l210.6-292c3.9-5.3.1-12.7-6.4-12.7z'
                }
            },
            {
                tag: 'path',
                attrs: {
                    d: 'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z'
                }
            }
        ]
    }
};
exports.default = CheckCircleOutline;

/***/ }),
/* 569 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CheckOutline = {
    name: 'check',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M912 190h-69.9c-9.8 0-19.1 4.5-25.1 12.2L404.7 724.5 207 474a32 32 0 0 0-25.1-12.2H112c-6.7 0-10.4 7.7-6.3 12.9l273.9 347c12.8 16.2 37.4 16.2 50.3 0l488.4-618.9c4.1-5.1.4-12.8-6.3-12.8z'
                }
            }
        ]
    }
};
exports.default = CheckOutline;

/***/ }),
/* 570 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CloseCircleOutline = {
    name: 'close-circle',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M685.4 354.8c0-4.4-3.6-8-8-8l-66 .3L512 465.6l-99.3-118.4-66.1-.3c-4.4 0-8 3.5-8 8 0 1.9.7 3.7 1.9 5.2l130.1 155L340.5 670a8.32 8.32 0 0 0-1.9 5.2c0 4.4 3.6 8 8 8l66.1-.3L512 564.4l99.3 118.4 66 .3c4.4 0 8-3.5 8-8 0-1.9-.7-3.7-1.9-5.2L553.5 515l130.1-155c1.2-1.4 1.8-3.3 1.8-5.2z'
                }
            },
            {
                tag: 'path',
                attrs: {
                    d: 'M512 65C264.6 65 64 265.6 64 513s200.6 448 448 448 448-200.6 448-448S759.4 65 512 65zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z'
                }
            }
        ]
    }
};
exports.default = CloseCircleOutline;

/***/ }),
/* 571 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var CloseOutline = {
    name: 'close',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M563.8 512l262.5-312.9c4.4-5.2.7-13.1-6.1-13.1h-79.8c-4.7 0-9.2 2.1-12.3 5.7L511.6 449.8 295.1 191.7c-3-3.6-7.5-5.7-12.3-5.7H203c-6.8 0-10.5 7.9-6.1 13.1L459.4 512 196.9 824.9A7.95 7.95 0 0 0 203 838h79.8c4.7 0 9.2-2.1 12.3-5.7l216.5-258.1 216.5 258.1c3 3.6 7.5 5.7 12.3 5.7h79.8c6.8 0 10.5-7.9 6.1-13.1L563.8 512z'
                }
            }
        ]
    }
};
exports.default = CloseOutline;

/***/ }),
/* 572 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var DeleteOutline = {
    name: 'delete',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M360 184h-8c4.4 0 8-3.6 8-8v8h304v-8c0 4.4 3.6 8 8 8h-8v72h72v-80c0-35.3-28.7-64-64-64H352c-35.3 0-64 28.7-64 64v80h72v-72zm504 72H160c-17.7 0-32 14.3-32 32v32c0 4.4 3.6 8 8 8h60.4l24.7 523c1.6 34.1 29.8 61 63.9 61h454c34.2 0 62.3-26.8 63.9-61l24.7-523H888c4.4 0 8-3.6 8-8v-32c0-17.7-14.3-32-32-32zM731.3 840H292.7l-24.2-512h487l-24.2 512z'
                }
            }
        ]
    }
};
exports.default = DeleteOutline;

/***/ }),
/* 573 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var DownOutline = {
    name: 'down',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z'
                }
            }
        ]
    }
};
exports.default = DownOutline;

/***/ }),
/* 574 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var EllipsisOutline = {
    name: 'ellipsis',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M176 511a56 56 0 1 0 112 0 56 56 0 1 0-112 0zm280 0a56 56 0 1 0 112 0 56 56 0 1 0-112 0zm280 0a56 56 0 1 0 112 0 56 56 0 1 0-112 0z'
                }
            }
        ]
    }
};
exports.default = EllipsisOutline;

/***/ }),
/* 575 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var ExclamationCircleOutline = {
    name: 'exclamation-circle',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z'
                }
            },
            {
                tag: 'path',
                attrs: {
                    d: 'M464 688a48 48 0 1 0 96 0 48 48 0 1 0-96 0zm24-112h48c4.4 0 8-3.6 8-8V296c0-4.4-3.6-8-8-8h-48c-4.4 0-8 3.6-8 8v272c0 4.4 3.6 8 8 8z'
                }
            }
        ]
    }
};
exports.default = ExclamationCircleOutline;

/***/ }),
/* 576 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var EyeOutline = {
    name: 'eye',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M942.2 486.2C847.4 286.5 704.1 186 512 186c-192.2 0-335.4 100.5-430.2 300.3a60.3 60.3 0 0 0 0 51.5C176.6 737.5 319.9 838 512 838c192.2 0 335.4-100.5 430.2-300.3 7.7-16.2 7.7-35 0-51.5zM512 766c-161.3 0-279.4-81.8-362.7-254C232.6 339.8 350.7 258 512 258c161.3 0 279.4 81.8 362.7 254C791.5 684.2 673.4 766 512 766zm-4-430c-97.2 0-176 78.8-176 176s78.8 176 176 176 176-78.8 176-176-78.8-176-176-176zm0 288c-61.9 0-112-50.1-112-112s50.1-112 112-112 112 50.1 112 112-50.1 112-112 112z'
                }
            }
        ]
    }
};
exports.default = EyeOutline;

/***/ }),
/* 577 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var FileOutline = {
    name: 'file',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM790.2 326H602V137.8L790.2 326zm1.8 562H232V136h302v216a42 42 0 0 0 42 42h216v494z'
                }
            }
        ]
    }
};
exports.default = FileOutline;

/***/ }),
/* 578 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var FilterOutline = {
    name: 'filter',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M880.1 154H143.9c-24.5 0-39.8 26.7-27.5 48L349 597.4V838c0 17.7 14.2 32 31.8 32h262.4c17.6 0 31.8-14.3 31.8-32V597.4L907.7 202c12.2-21.3-3.1-48-27.6-48zM603.4 798H420.6V642h182.9v156zm9.6-236.6l-9.5 16.6h-183l-9.5-16.6L212.7 226h598.6L613 561.4z'
                }
            }
        ]
    }
};
exports.default = FilterOutline;

/***/ }),
/* 579 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var FolderOpenOutline = {
    name: 'folder-open',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M928 444H820V330.4c0-17.7-14.3-32-32-32H473L355.7 186.2a8.15 8.15 0 0 0-5.5-2.2H96c-17.7 0-32 14.3-32 32v592c0 17.7 14.3 32 32 32h698c13 0 24.8-7.9 29.7-20l134-332c1.5-3.8 2.3-7.9 2.3-12 0-17.7-14.3-32-32-32zM136 256h188.5l119.6 114.4H748V444H238c-13 0-24.8 7.9-29.7 20L136 643.2V256zm635.3 512H159l103.3-256h612.4L771.3 768z'
                }
            }
        ]
    }
};
exports.default = FolderOpenOutline;

/***/ }),
/* 580 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var FolderOutline = {
    name: 'folder',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M880 298.4H521L403.7 186.2a8.15 8.15 0 0 0-5.5-2.2H144c-17.7 0-32 14.3-32 32v592c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V330.4c0-17.7-14.3-32-32-32zM840 768H184V256h188.5l119.6 114.4H840V768z'
                }
            }
        ]
    }
};
exports.default = FolderOutline;

/***/ }),
/* 581 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var InfoCircleOutline = {
    name: 'info-circle',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z'
                }
            },
            {
                tag: 'path',
                attrs: {
                    d: 'M464 336a48 48 0 1 0 96 0 48 48 0 1 0-96 0zm72 112h-48c-4.4 0-8 3.6-8 8v272c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V456c0-4.4-3.6-8-8-8z'
                }
            }
        ]
    }
};
exports.default = InfoCircleOutline;

/***/ }),
/* 582 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var LeftOutline = {
    name: 'left',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M724 218.3V141c0-6.7-7.7-10.4-12.9-6.3L260.3 486.8a31.86 31.86 0 0 0 0 50.3l450.8 352.1c5.3 4.1 12.9.4 12.9-6.3v-77.3c0-4.9-2.3-9.6-6.1-12.6l-360-281 360-281.1c3.8-3 6.1-7.7 6.1-12.6z'
                }
            }
        ]
    }
};
exports.default = LeftOutline;

/***/ }),
/* 583 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var LoadingOutline = {
    name: 'loading',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '0 0 1024 1024' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M988 548c-19.9 0-36-16.1-36-36 0-59.4-11.6-117-34.6-171.3a440.45 440.45 0 0 0-94.3-139.9 437.71 437.71 0 0 0-139.9-94.3C629 83.6 571.4 72 512 72c-19.9 0-36-16.1-36-36s16.1-36 36-36c69.1 0 136.2 13.5 199.3 40.3C772.3 66 827 103 874 150c47 47 83.9 101.8 109.7 162.7 26.7 63.1 40.2 130.2 40.2 199.3.1 19.9-16 36-35.9 36z'
                }
            }
        ]
    }
};
exports.default = LoadingOutline;

/***/ }),
/* 584 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var PaperClipOutline = {
    name: 'paper-clip',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M779.3 196.6c-94.2-94.2-247.6-94.2-341.7 0l-261 260.8c-1.7 1.7-2.6 4-2.6 6.4s.9 4.7 2.6 6.4l36.9 36.9a9 9 0 0 0 12.7 0l261-260.8c32.4-32.4 75.5-50.2 121.3-50.2s88.9 17.8 121.2 50.2c32.4 32.4 50.2 75.5 50.2 121.2 0 45.8-17.8 88.8-50.2 121.2l-266 265.9-43.1 43.1c-40.3 40.3-105.8 40.3-146.1 0-19.5-19.5-30.2-45.4-30.2-73s10.7-53.5 30.2-73l263.9-263.8c6.7-6.6 15.5-10.3 24.9-10.3h.1c9.4 0 18.1 3.7 24.7 10.3 6.7 6.7 10.3 15.5 10.3 24.9 0 9.3-3.7 18.1-10.3 24.7L372.4 653c-1.7 1.7-2.6 4-2.6 6.4s.9 4.7 2.6 6.4l36.9 36.9a9 9 0 0 0 12.7 0l215.6-215.6c19.9-19.9 30.8-46.3 30.8-74.4s-11-54.6-30.8-74.4c-41.1-41.1-107.9-41-149 0L463 364 224.8 602.1A172.22 172.22 0 0 0 174 724.8c0 46.3 18.1 89.8 50.8 122.5 33.9 33.8 78.3 50.7 122.7 50.7 44.4 0 88.8-16.9 122.6-50.7l309.2-309C824.8 492.7 850 432 850 367.5c.1-64.6-25.1-125.3-70.7-170.9z'
                }
            }
        ]
    }
};
exports.default = PaperClipOutline;

/***/ }),
/* 585 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var PictureOutline = {
    name: 'picture',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M928 160H96c-17.7 0-32 14.3-32 32v640c0 17.7 14.3 32 32 32h832c17.7 0 32-14.3 32-32V192c0-17.7-14.3-32-32-32zm-40 632H136v-39.9l138.5-164.3 150.1 178L658.1 489 888 761.6V792zm0-129.8L664.2 396.8c-3.2-3.8-9-3.8-12.2 0L424.6 666.4l-144-170.7c-3.2-3.8-9-3.8-12.2 0L136 652.7V232h752v430.2zM304 456a88 88 0 1 0 0-176 88 88 0 0 0 0 176zm0-116c15.5 0 28 12.5 28 28s-12.5 28-28 28-28-12.5-28-28 12.5-28 28-28z'
                }
            }
        ]
    }
};
exports.default = PictureOutline;

/***/ }),
/* 586 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var PlusOutline = {
    name: 'plus',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M848 474H550V152h-76v322H176c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h298v322h76V550h298c4.4 0 8-3.6 8-8v-60c0-4.4-3.6-8-8-8z'
                }
            }
        ]
    }
};
exports.default = PlusOutline;

/***/ }),
/* 587 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var RedoOutline = {
    name: 'redo',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M758.2 839.1C851.8 765.9 912 651.9 912 523.9 912 303 733.5 124.3 512.6 124 291.4 123.7 112 302.8 112 523.9c0 125.2 57.5 236.9 147.6 310.2 3.5 2.8 8.6 2.2 11.4-1.3l39.4-50.5c2.7-3.4 2.1-8.3-1.2-11.1-8.1-6.6-15.9-13.7-23.4-21.2a318.64 318.64 0 0 1-68.6-101.7C200.4 609 192 567.1 192 523.9s8.4-85.1 25.1-124.5c16.1-38.1 39.2-72.3 68.6-101.7 29.4-29.4 63.6-52.5 101.7-68.6C426.9 212.4 468.8 204 512 204s85.1 8.4 124.5 25.1c38.1 16.1 72.3 39.2 101.7 68.6 29.4 29.4 52.5 63.6 68.6 101.7 16.7 39.4 25.1 81.3 25.1 124.5s-8.4 85.1-25.1 124.5a318.64 318.64 0 0 1-68.6 101.7c-9.3 9.3-19.1 18-29.3 26L668.2 724a8 8 0 0 0-14.1 3l-39.6 162.2c-1.2 5 2.6 9.9 7.7 9.9l167 .8c6.7 0 10.5-7.7 6.3-12.9l-37.3-47.9z'
                }
            }
        ]
    }
};
exports.default = RedoOutline;

/***/ }),
/* 588 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var RightOutline = {
    name: 'right',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M765.7 486.8L314.9 134.7A7.97 7.97 0 0 0 302 141v77.3c0 4.9 2.3 9.6 6.1 12.6l360 281.1-360 281.1c-3.9 3-6.1 7.7-6.1 12.6V883c0 6.7 7.7 10.4 12.9 6.3l450.8-352.1a31.96 31.96 0 0 0 0-50.4z'
                }
            }
        ]
    }
};
exports.default = RightOutline;

/***/ }),
/* 589 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var SearchOutline = {
    name: 'search',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M909.6 854.5L649.9 594.8C690.2 542.7 712 479 712 412c0-80.2-31.3-155.4-87.9-212.1-56.6-56.7-132-87.9-212.1-87.9s-155.5 31.3-212.1 87.9C143.2 256.5 112 331.8 112 412c0 80.1 31.3 155.5 87.9 212.1C256.5 680.8 331.8 712 412 712c67 0 130.6-21.8 182.7-62l259.7 259.6a8.2 8.2 0 0 0 11.6 0l43.6-43.5a8.2 8.2 0 0 0 0-11.6zM570.4 570.4C528 612.7 471.8 636 412 636s-116-23.3-158.4-65.6C211.3 528 188 471.8 188 412s23.3-116.1 65.6-158.4C296 211.3 352.2 188 412 188s116.1 23.2 158.4 65.6S636 352.2 636 412s-23.3 116.1-65.6 158.4z'
                }
            }
        ]
    }
};
exports.default = SearchOutline;

/***/ }),
/* 590 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var UpOutline = {
    name: 'up',
    theme: 'outline',
    icon: {
        tag: 'svg',
        attrs: { viewBox: '64 64 896 896' },
        children: [
            {
                tag: 'path',
                attrs: {
                    d: 'M890.5 755.3L537.9 269.2c-12.8-17.6-39-17.6-51.7 0L133.5 755.3A8 8 0 0 0 140 768h75c5.1 0 9.9-2.5 12.9-6.6L512 369.8l284.1 391.6c3 4.1 7.8 6.6 12.9 6.6h75c6.5 0 10.3-7.4 6.5-12.7z'
                }
            }
        ]
    }
};
exports.default = UpOutline;

/***/ }),
/* 591 */
/***/ (function(module, exports) {

function _interopRequireDefault(obj) {
  return obj && obj.__esModule ? obj : {
    "default": obj
  };
}

module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),
/* 592 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * @ignore
 * base event object for custom and dom event.
 * @author yiminghe@gmail.com
 */

Object.defineProperty(exports, "__esModule", {
  value: true
});
function returnFalse() {
  return false;
}

function returnTrue() {
  return true;
}

function EventBaseObject() {
  this.timeStamp = Date.now();
  this.target = undefined;
  this.currentTarget = undefined;
}

EventBaseObject.prototype = {
  isEventObject: 1,

constructor: EventBaseObject,

isDefaultPrevented: returnFalse,

isPropagationStopped: returnFalse,

isImmediatePropagationStopped: returnFalse,

preventDefault: function preventDefault() {
    this.isDefaultPrevented = returnTrue;
  },

stopPropagation: function stopPropagation() {
    this.isPropagationStopped = returnTrue;
  },

stopImmediatePropagation: function stopImmediatePropagation() {
    this.isImmediatePropagationStopped = returnTrue;
    // fixed 1.2
    // call stopPropagation implicitly
    this.stopPropagation();
  },

halt: function halt(immediate) {
    if (immediate) {
      this.stopImmediatePropagation();
    } else {
      this.stopPropagation();
    }
    this.preventDefault();
  }
};

exports["default"] = EventBaseObject;
module.exports = exports["default"];

/***/ }),
/* 593 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * @ignore
 * event object for dom
 * @author yiminghe@gmail.com
 */

Object.defineProperty(exports, '__esModule', {
  value: true
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _EventBaseObject = __webpack_require__(592);

var _EventBaseObject2 = _interopRequireDefault(_EventBaseObject);

var _objectAssign = __webpack_require__(24);

var _objectAssign2 = _interopRequireDefault(_objectAssign);

var TRUE = true;
var FALSE = false;
var commonProps = ['altKey', 'bubbles', 'cancelable', 'ctrlKey', 'currentTarget', 'eventPhase', 'metaKey', 'shiftKey', 'target', 'timeStamp', 'view', 'type'];

function isNullOrUndefined(w) {
  return w === null || w === undefined;
}

var eventNormalizers = [{
  reg: /^key/,
  props: ['char', 'charCode', 'key', 'keyCode', 'which'],
  fix: function fix(event, nativeEvent) {
    if (isNullOrUndefined(event.which)) {
      event.which = !isNullOrUndefined(nativeEvent.charCode) ? nativeEvent.charCode : nativeEvent.keyCode;
    }

// add metaKey to non-Mac browsers (use ctrl for PC 's and Meta for Macs)
    if (event.metaKey === undefined) {
      event.metaKey = event.ctrlKey;
    }
  }
}, {
  reg: /^touch/,
  props: ['touches', 'changedTouches', 'targetTouches']
}, {
  reg: /^hashchange$/,
  props: ['newURL', 'oldURL']
}, {
  reg: /^gesturechange$/i,
  props: ['rotation', 'scale']
}, {
  reg: /^(mousewheel|DOMMouseScroll)$/,
  props: [],
  fix: function fix(event, nativeEvent) {
    var deltaX = undefined;
    var deltaY = undefined;
    var delta = undefined;
    var wheelDelta = nativeEvent.wheelDelta;
    var axis = nativeEvent.axis;
    var wheelDeltaY = nativeEvent.wheelDeltaY;
    var wheelDeltaX = nativeEvent.wheelDeltaX;
    var detail = nativeEvent.detail;

// ie/webkit
    if (wheelDelta) {
      delta = wheelDelta / 120;
    }

// gecko
    if (detail) {
      // press control e.detail == 1 else e.detail == 3
      delta = 0 - (detail % 3 === 0 ? detail / 3 : detail);
    }

// Gecko
    if (axis !== undefined) {
      if (axis === event.HORIZONTAL_AXIS) {
        deltaY = 0;
        deltaX = 0 - delta;
      } else if (axis === event.VERTICAL_AXIS) {
        deltaX = 0;
        deltaY = delta;
      }
    }

// Webkit
    if (wheelDeltaY !== undefined) {
      deltaY = wheelDeltaY / 120;
    }
    if (wheelDeltaX !== undefined) {
      deltaX = -1 * wheelDeltaX / 120;
    }

// 默认 deltaY (ie)
    if (!deltaX && !deltaY) {
      deltaY = delta;
    }

if (deltaX !== undefined) {
      /**
       * deltaX of mousewheel event
       * @property deltaX
       * @member Event.DomEvent.Object
       */
      event.deltaX = deltaX;
    }

if (deltaY !== undefined) {
      /**
       * deltaY of mousewheel event
       * @property deltaY
       * @member Event.DomEvent.Object
       */
      event.deltaY = deltaY;
    }

if (delta !== undefined) {
      /**
       * delta of mousewheel event
       * @property delta
       * @member Event.DomEvent.Object
       */
      event.delta = delta;
    }
  }
}, {
  reg: /^mouse|contextmenu|click|mspointer|(^DOMMouseScroll$)/i,
  props: ['buttons', 'clientX', 'clientY', 'button', 'offsetX', 'relatedTarget', 'which', 'fromElement', 'toElement', 'offsetY', 'pageX', 'pageY', 'screenX', 'screenY'],
  fix: function fix(event, nativeEvent) {
    var eventDoc = undefined;
    var doc = undefined;
    var body = undefined;
    var target = event.target;
    var button = nativeEvent.button;

// Calculate pageX/Y if missing and clientX/Y available
    if (target && isNullOrUndefined(event.pageX) && !isNullOrUndefined(nativeEvent.clientX)) {
      eventDoc = target.ownerDocument || document;
      doc = eventDoc.documentElement;
      body = eventDoc.body;
      event.pageX = nativeEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
      event.pageY = nativeEvent.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
    }

// which for click: 1 === left; 2 === middle; 3 === right
    // do not use button
    if (!event.which && button !== undefined) {
      if (button & 1) {
        event.which = 1;
      } else if (button & 2) {
        event.which = 3;
      } else if (button & 4) {
        event.which = 2;
      } else {
        event.which = 0;
      }
    }

// add relatedTarget, if necessary
    if (!event.relatedTarget && event.fromElement) {
      event.relatedTarget = event.fromElement === target ? event.toElement : event.fromElement;
    }

return event;
  }
}];

function retTrue() {
  return TRUE;
}

function retFalse() {
  return FALSE;
}

function DomEventObject(nativeEvent) {
  var type = nativeEvent.type;

var isNative = typeof nativeEvent.stopPropagation === 'function' || typeof nativeEvent.cancelBubble === 'boolean';

_EventBaseObject2['default'].call(this);

this.nativeEvent = nativeEvent;

// in case dom event has been mark as default prevented by lower dom node
  var isDefaultPrevented = retFalse;
  if ('defaultPrevented' in nativeEvent) {
    isDefaultPrevented = nativeEvent.defaultPrevented ? retTrue : retFalse;
  } else if ('getPreventDefault' in nativeEvent) {
    // https://bugzilla.mozilla.org/show_bug.cgi?id=691151
    isDefaultPrevented = nativeEvent.getPreventDefault() ? retTrue : retFalse;
  } else if ('returnValue' in nativeEvent) {
    isDefaultPrevented = nativeEvent.returnValue === FALSE ? retTrue : retFalse;
  }

this.isDefaultPrevented = isDefaultPrevented;

var fixFns = [];
  var fixFn = undefined;
  var l = undefined;
  var prop = undefined;
  var props = commonProps.concat();

eventNormalizers.forEach(function (normalizer) {
    if (type.match(normalizer.reg)) {
      props = props.concat(normalizer.props);
      if (normalizer.fix) {
        fixFns.push(normalizer.fix);
      }
    }
  });

l = props.length;

// clone properties of the original event object
  while (l) {
    prop = props[--l];
    this[prop] = nativeEvent[prop];
  }

// fix target property, if necessary
  if (!this.target && isNative) {
    this.target = nativeEvent.srcElement || document; // srcElement might not be defined either
  }

// check if target is a text node (safari)
  if (this.target && this.target.nodeType === 3) {
    this.target = this.target.parentNode;
  }

l = fixFns.length;

while (l) {
    fixFn = fixFns[--l];
    fixFn(this, nativeEvent);
  }

this.timeStamp = nativeEvent.timeStamp || Date.now();
}

var EventBaseObjectProto = _EventBaseObject2['default'].prototype;

(0, _objectAssign2['default'])(DomEventObject.prototype, EventBaseObjectProto, {
  constructor: DomEventObject,

preventDefault: function preventDefault() {
    var e = this.nativeEvent;

// if preventDefault exists run it on the original event
    if (e.preventDefault) {
      e.preventDefault();
    } else {
      // otherwise set the returnValue property of the original event to FALSE (IE)
      e.returnValue = FALSE;
    }

EventBaseObjectProto.preventDefault.call(this);
  },

stopPropagation: function stopPropagation() {
    var e = this.nativeEvent;

// if stopPropagation exists run it on the original event
    if (e.stopPropagation) {
      e.stopPropagation();
    } else {
      // otherwise set the cancelBubble property of the original event to TRUE (IE)
      e.cancelBubble = TRUE;
    }

EventBaseObjectProto.stopPropagation.call(this);
  }
});

exports['default'] = DomEventObject;
module.exports = exports['default'];

/***/ }),
/* 594 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, '__esModule', {
  value: true
});
exports['default'] = addEventListener;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _EventObject = __webpack_require__(593);

var _EventObject2 = _interopRequireDefault(_EventObject);

function addEventListener(target, eventType, callback, option) {
  function wrapCallback(e) {
    var ne = new _EventObject2['default'](e);
    callback.call(target, ne);
  }

if (target.addEventListener) {
    var _ret = (function () {
      var useCapture = false;
      if (typeof option === 'object') {
        useCapture = option.capture || false;
      } else if (typeof option === 'boolean') {
        useCapture = option;
      }

target.addEventListener(eventType, wrapCallback, option || false);

return {
        v: {
          remove: function remove() {
            target.removeEventListener(eventType, wrapCallback, useCapture);
          }
        }
      };
    })();

if (typeof _ret === 'object') return _ret.v;
  } else if (target.attachEvent) {
    target.attachEvent('on' + eventType, wrapCallback);
    return {
      remove: function remove() {
        target.detachEvent('on' + eventType, wrapCallback);
      }
    };
  }
}

module.exports = exports['default'];

/***/ }),
/* 595 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = generate;

var _tinycolor = __webpack_require__(553);

var _tinycolor2 = _interopRequireDefault(_tinycolor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var hueStep = 2; // 色相阶梯
var saturationStep = 16; // 饱和度阶梯，浅色部分
var saturationStep2 = 5; // 饱和度阶梯，深色部分
var brightnessStep1 = 5; // 亮度阶梯，浅色部分
var brightnessStep2 = 15; // 亮度阶梯，深色部分
var lightColorCount = 5; // 浅色数量，主色上
var darkColorCount = 4; // 深色数量，主色下

function getValue(hsv, i, light) {
  if (light) {
    return Math.round(hsv.v * 100) + brightnessStep1 * i;
  }
  return Math.round(hsv.v * 100) - brightnessStep2 * i;
}

/***/ }),
/* 596 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.presetPrimaryColors = exports.presetPalettes = exports.generate = undefined;

var _generate = __webpack_require__(595);

var _generate2 = _interopRequireDefault(_generate);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var presetPrimaryColors = {
  red: '#F5222D',
  volcano: '#FA541C',
  orange: '#FA8C16',
  gold: '#FAAD14',
  yellow: '#FADB14',
  lime: '#A0D911',
  green: '#52C41A',
  cyan: '#13C2C2',
  blue: '#1890FF',
  geekblue: '#2F54EB',
  purple: '#722ED1',
  magenta: '#EB2F96',
  grey: '#666666'
};

var presetPalettes = {};

Object.keys(presetPrimaryColors).forEach(function (key) {
  presetPalettes[key] = (0, _generate2.default)(presetPrimaryColors[key]);
});

exports.generate = _generate2.default;
exports.presetPalettes = presetPalettes;
exports.presetPrimaryColors = presetPrimaryColors;

/***/ }),
/* 597 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_css_animation__ = __webpack_require__(260);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_raf__ = __webpack_require__(298);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_raf___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_raf__);

/***/ }),
/* 598 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = wrapperRaf;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_raf__ = __webpack_require__(298);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_raf___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_raf__);

var id = 0;
var ids = {};
// Support call raf with delay specified frame
function wrapperRaf(callback) {
    var delayFrames = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;

/***/ }),
/* 599 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var InputElement = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(InputElement, _React$Component);

function InputElement() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, InputElement);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (InputElement.__proto__ || Object.getPrototypeOf(InputElement)).apply(this, arguments));

_this.focus = function () {
            _this.ele.focus ? _this.ele.focus() : __WEBPACK_IMPORTED_MODULE_6_react_dom__["findDOMNode"](_this.ele).focus();
        };
        _this.blur = function () {
            _this.ele.blur ? _this.ele.blur() : __WEBPACK_IMPORTED_MODULE_6_react_dom__["findDOMNode"](_this.ele).blur();
        };
        _this.saveRef = function (ele) {
            _this.ele = ele;
            var childRef = _this.props.children.ref;

if (typeof childRef === 'function') {
                childRef(ele);
            }
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(InputElement, [{
        key: 'render',
        value: function render() {
            return __WEBPACK_IMPORTED_MODULE_5_react__["cloneElement"](this.props.children, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, this.props, { ref: this.saveRef }), null);
        }
    }]);

return InputElement;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (InputElement);

/***/ }),
/* 600 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof__ = __webpack_require__(161);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_typeof__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_select__ = __webpack_require__(473);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__select__ = __webpack_require__(65);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__input__ = __webpack_require__(77);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__InputElement__ = __webpack_require__(599);

function isSelectOptionOrSelectOptGroup(child) {
    return child && child.type && (child.type.isSelectOption || child.type.isSelectOptGroup);
}

var AutoComplete = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default()(AutoComplete, _React$Component);

function AutoComplete() {
        __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default()(this, AutoComplete);

var _this = __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default()(this, (AutoComplete.__proto__ || Object.getPrototypeOf(AutoComplete)).apply(this, arguments));

_this.getInputElement = function () {
            var children = _this.props.children;

var element = children && __WEBPACK_IMPORTED_MODULE_7_react__["isValidElement"](children) && children.type !== __WEBPACK_IMPORTED_MODULE_8_rc_select__["b" /* Option */] ? __WEBPACK_IMPORTED_MODULE_7_react__["Children"].only(_this.props.children) : __WEBPACK_IMPORTED_MODULE_7_react__["createElement"](__WEBPACK_IMPORTED_MODULE_11__input__["default"], null);
            var elementProps = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_extends___default()({}, element.props);
            // https://github.com/ant-design/ant-design/pull/7742
            delete elementProps.children;
            return __WEBPACK_IMPORTED_MODULE_7_react__["createElement"](
                __WEBPACK_IMPORTED_MODULE_12__InputElement__["a" /* default */],
                elementProps,
                element
            );
        };
        _this.saveSelect = function (node) {
            _this.select = node;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default()(AutoComplete, [{
        key: 'focus',
        value: function focus() {
            this.select.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.select.blur();
        }
    }, {
        key: 'render',
        value: function render() {
            var _classNames;

var _props = this.props,
                size = _props.size,
                _props$className = _props.className,
                className = _props$className === undefined ? '' : _props$className,
                notFoundContent = _props.notFoundContent,
                prefixCls = _props.prefixCls,
                optionLabelProp = _props.optionLabelProp,
                dataSource = _props.dataSource,
                children = _props.children;

return AutoComplete;
}(__WEBPACK_IMPORTED_MODULE_7_react__["Component"]);

/* harmony default export */ __webpack_exports__["default"] = (AutoComplete);

AutoComplete.Option = __WEBPACK_IMPORTED_MODULE_8_rc_select__["b" /* Option */];
AutoComplete.OptGroup = __WEBPACK_IMPORTED_MODULE_8_rc_select__["c" /* OptGroup */];
AutoComplete.defaultProps = {
    prefixCls: 'ant-select',
    transitionName: 'slide-up',
    optionLabelProp: 'children',
    choiceTransitionName: 'zoom',
    showSearch: false,
    filterOption: false
};

/***/ }),
/* 601 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(915);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__select_style__ = __webpack_require__(66);

/***/ }),
/* 602 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var ButtonGroup = function ButtonGroup(props) {
    var _props$prefixCls = props.prefixCls,
        prefixCls = _props$prefixCls === undefined ? 'ant-btn-group' : _props$prefixCls,
        size = props.size,
        className = props.className,
        others = __rest(props, ["prefixCls", "size", "className"]);
    // large => lg
    // small => sm

/***/ }),
/* 603 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__util_wave__ = __webpack_require__(344);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__icon__ = __webpack_require__(52);

var Button = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Button, _React$Component);

function Button(props) {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Button);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Button.__proto__ || Object.getPrototypeOf(Button)).call(this, props));

_this.saveButtonRef = function (node) {
            _this.buttonNode = node;
        };
        _this.handleClick = function (e) {
            var loading = _this.state.loading;
            var onClick = _this.props.onClick;

if (!!loading) {
                return;
            }
            if (onClick) {
                onClick(e);
            }
        };
        _this.state = {
            loading: props.loading,
            hasTwoCNChar: false
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Button, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
            this.fixTwoCNChar();
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            var _this2 = this;

return __WEBPACK_IMPORTED_MODULE_6_react__["Children"].count(children) === 1 && !icon;
        }
    }, {
        key: 'render',
        value: function render() {
            var _classNames,
                _this3 = this;

var _a = this.props,
                type = _a.type,
                shape = _a.shape,
                size = _a.size,
                className = _a.className,
                children = _a.children,
                icon = _a.icon,
                prefixCls = _a.prefixCls,
                ghost = _a.ghost,
                _loadingProp = _a.loading,
                block = _a.block,
                rest = __rest(_a, ["type", "shape", "size", "className", "children", "icon", "prefixCls", "ghost", "loading", "block"]);var _state = this.state,
                loading = _state.loading,
                hasTwoCNChar = _state.hasTwoCNChar;
            // large => lg
            // small => sm

return Button;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (Button);

Button.__ANT_BUTTON = true;
Button.defaultProps = {
    prefixCls: 'ant-btn',
    loading: false,
    ghost: false,
    block: false
};
Button.propTypes = {
    type: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    shape: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOf"](['circle', 'circle-outline']),
    size: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOf"](['large', 'default', 'small']),
    htmlType: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOf"](['submit', 'button', 'reset']),
    onClick: __WEBPACK_IMPORTED_MODULE_7_prop_types__["func"],
    loading: __WEBPACK_IMPORTED_MODULE_7_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_7_prop_types__["bool"], __WEBPACK_IMPORTED_MODULE_7_prop_types__["object"]]),
    className: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    icon: __WEBPACK_IMPORTED_MODULE_7_prop_types__["string"],
    block: __WEBPACK_IMPORTED_MODULE_7_prop_types__["bool"]
};

/***/ }),
/* 604 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__date_picker_locale_en_US__ = __webpack_require__(346);

/* harmony default export */ __webpack_exports__["a"] = (__WEBPACK_IMPORTED_MODULE_0__date_picker_locale_en_US__["a" /* default */]);

/***/ }),
/* 605 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_toConsumableArray__ = __webpack_require__(160);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_toConsumableArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_toConsumableArray__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_react_lifecycles_compat__ = __webpack_require__(61);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_shallowequal__ = __webpack_require__(115);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_shallowequal___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_10_shallowequal__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11_omit_js__ = __webpack_require__(138);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__Checkbox__ = __webpack_require__(345);

var CheckboxGroup = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(CheckboxGroup, _React$Component);

function CheckboxGroup(props) {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, CheckboxGroup);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (CheckboxGroup.__proto__ || Object.getPrototypeOf(CheckboxGroup)).call(this, props));

_this.toggleOption = function (option) {
            var optionIndex = _this.state.value.indexOf(option.value);
            var value = [].concat(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_toConsumableArray___default()(_this.state.value));
            if (optionIndex === -1) {
                value.push(option.value);
            } else {
                value.splice(optionIndex, 1);
            }
            if (!('value' in _this.props)) {
                _this.setState({ value: value });
            }
            var onChange = _this.props.onChange;
            if (onChange) {
                onChange(value);
            }
        };
        _this.state = {
            value: props.value || props.defaultValue || []
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(CheckboxGroup, [{
        key: 'getChildContext',
        value: function getChildContext() {
            return {
                checkboxGroup: {
                    toggleOption: this.toggleOption,
                    value: this.state.value,
                    disabled: this.props.disabled
                }
            };
        }
    }, {
        key: 'shouldComponentUpdate',
        value: function shouldComponentUpdate(nextProps, nextState) {
            return !__WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.props, nextProps) || !__WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.state, nextState);
        }
    }, {
        key: 'getOptions',
        value: function getOptions() {
            var options = this.props.options;
            // https://github.com/Microsoft/TypeScript/issues/7960

return options.map(function (option) {
                if (typeof option === 'string') {
                    return {
                        label: option,
                        value: option
                    };
                }
                return option;
            });
        }
    }, {
        key: 'render',
        value: function render() {
            var props = this.props,
                state = this.state;

var prefixCls = props.prefixCls,
                className = props.className,
                style = props.style,
                options = props.options,
                restProps = __rest(props, ["prefixCls", "className", "style", "options"]);

return CheckboxGroup;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

CheckboxGroup.defaultProps = {
    options: [],
    prefixCls: 'ant-checkbox'
};
CheckboxGroup.propTypes = {
    defaultValue: __WEBPACK_IMPORTED_MODULE_7_prop_types__["array"],
    value: __WEBPACK_IMPORTED_MODULE_7_prop_types__["array"],
    options: __WEBPACK_IMPORTED_MODULE_7_prop_types__["array"].isRequired,
    onChange: __WEBPACK_IMPORTED_MODULE_7_prop_types__["func"]
};
CheckboxGroup.childContextTypes = {
    checkboxGroup: __WEBPACK_IMPORTED_MODULE_7_prop_types__["any"]
};
__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8_react_lifecycles_compat__["polyfill"])(CheckboxGroup);
/* harmony default export */ __webpack_exports__["a"] = (CheckboxGroup);

/***/ }),
/* 606 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony export (immutable) */ __webpack_exports__["default"] = Divider;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_classnames__);

function Divider(_a) {
    var _classNames;

var _a$prefixCls = _a.prefixCls,
        prefixCls = _a$prefixCls === undefined ? 'ant' : _a$prefixCls,
        _a$type = _a.type,
        type = _a$type === undefined ? 'horizontal' : _a$type,
        _a$orientation = _a.orientation,
        orientation = _a$orientation === undefined ? '' : _a$orientation,
        className = _a.className,
        children = _a.children,
        dashed = _a.dashed,
        restProps = __rest(_a, ["prefixCls", "type", "orientation", "className", "children", "dashed"]);

/***/ }),
/* 607 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(918);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);

/***/ }),
/* 608 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = create;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index__ = __webpack_require__(52);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_react__);

var customCache = new Set();
function create() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var scriptUrl = options.scriptUrl,
        _options$extraCommonP = options.extraCommonProps,
        extraCommonProps = _options$extraCommonP === undefined ? {} : _options$extraCommonP;
    /**
     * DOM API required.
     * Make sure in browser environment.
     * The Custom Icon will create a <script/>
     * that loads SVG symbols and insert the SVG Element into the document body.
     */

if (typeof document !== 'undefined' && typeof window !== 'undefined' && typeof document.createElement === 'function' && typeof scriptUrl === 'string' && scriptUrl.length && !customCache.has(scriptUrl)) {
        var script = document.createElement('script');
        script.setAttribute('src', scriptUrl);
        script.setAttribute('data-namespace', scriptUrl);
        customCache.add(scriptUrl);
        document.body.appendChild(script);
    }
    var Iconfont = function Iconfont(props) {
        var type = props.type,
            children = props.children,
            restProps = __rest(props, ["type", "children"]);
        // component > children > type

/***/ }),
/* 609 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = setTwoToneColor;
/* harmony export (immutable) */ __webpack_exports__["b"] = getTwoToneColor;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__ant_design_icons_react__ = __webpack_require__(343);

/***/ }),
/* 610 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return svgBaseProps; });
/* harmony export (immutable) */ __webpack_exports__["b"] = getThemeFromTypeName;
/* harmony export (immutable) */ __webpack_exports__["d"] = removeTypeTheme;
/* harmony export (immutable) */ __webpack_exports__["c"] = withThemeSuffix;
/* harmony export (immutable) */ __webpack_exports__["e"] = alias;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__util_warning__ = __webpack_require__(202);

var _svgBaseProps;

// These props make sure that the SVG behaviours like general text.
// Reference: https://blog.prototypr.io/align-svg-icons-to-text-and-say-goodbye-to-font-icons-d44b3d7b26b4
var svgBaseProps = (_svgBaseProps = {
    width: '1em',
    height: '1em',
    fill: 'currentColor'
}, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_svgBaseProps, 'aria-hidden', 'true'), __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_svgBaseProps, 'focusable', 'false'), _svgBaseProps);
var fillTester = /-fill$/;
var outlineTester = /-o$/;
var twoToneTester = /-twotone$/;
function getThemeFromTypeName(type) {
    var result = null;
    if (fillTester.test(type)) {
        result = 'filled';
    } else if (outlineTester.test(type)) {
        result = 'outlined';
    } else if (twoToneTester.test(type)) {
        result = 'twoTone';
    }
    return result;
}
function removeTypeTheme(type) {
    return type.replace(fillTester, '').replace(outlineTester, '').replace(twoToneTester, '');
}
function withThemeSuffix(type, theme) {
    var result = type;
    if (theme === 'filled') {
        result += '-fill';
    } else if (theme === 'outlined') {
        result += '-o';
    } else if (theme === 'twoTone') {
        result += '-twotone';
    } else {
        __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1__util_warning__["a" /* default */])(false, 'This icon \'' + type + '\' has unknown theme \'' + theme + '\'');
    }
    return result;
}
// For alias or compatibility
function alias(type) {
    switch (type) {
        case 'cross':
            return 'close';
        default:
    }
    return type;
}

/***/ }),
/* 611 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_input_number__ = __webpack_require__(1140);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__icon__ = __webpack_require__(52);

var InputNumber = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(InputNumber, _React$Component);

function InputNumber() {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, InputNumber);

return __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (InputNumber.__proto__ || Object.getPrototypeOf(InputNumber)).apply(this, arguments));
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(InputNumber, [{
        key: 'render',
        value: function render() {
            var _classNames,
                _this2 = this;

return InputNumber;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["default"] = (InputNumber);

InputNumber.defaultProps = {
    prefixCls: 'ant-input-number',
    step: 1
};

/***/ }),
/* 612 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(920);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);

/***/ }),
/* 613 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var Group = function Group(props) {
    var _classNames;

var _props$prefixCls = props.prefixCls,
        prefixCls = _props$prefixCls === undefined ? 'ant-input-group' : _props$prefixCls,
        _props$className = props.className,
        className = _props$className === undefined ? '' : _props$className;

var cls = __WEBPACK_IMPORTED_MODULE_2_classnames___default()(prefixCls, (_classNames = {}, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-lg', props.size === 'large'), __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-sm', props.size === 'small'), __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-compact', props.compact), _classNames), className);
    return __WEBPACK_IMPORTED_MODULE_1_react__["createElement"](
        'span',
        { className: cls, style: props.style, onMouseEnter: props.onMouseEnter, onMouseLeave: props.onMouseLeave, onFocus: props.onFocus, onBlur: props.onBlur },
        props.children
    );
};
/* harmony default export */ __webpack_exports__["a"] = (Group);

/***/ }),
/* 614 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__Input__ = __webpack_require__(348);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__icon__ = __webpack_require__(52);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__button__ = __webpack_require__(149);

var Search = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Search, _React$Component);

function Search() {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Search);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Search.__proto__ || Object.getPrototypeOf(Search)).apply(this, arguments));

_this.onSearch = function (e) {
            var onSearch = _this.props.onSearch;

if (onSearch) {
                onSearch(_this.input.input.value, e);
            }
            _this.input.focus();
        };
        _this.saveInput = function (node) {
            _this.input = node;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Search, [{
        key: 'focus',
        value: function focus() {
            this.input.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.input.blur();
        }
    }, {
        key: 'getButtonOrIcon',
        value: function getButtonOrIcon() {
            var _props = this.props,
                enterButton = _props.enterButton,
                prefixCls = _props.prefixCls,
                size = _props.size,
                disabled = _props.disabled;

return Search;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (Search);

Search.defaultProps = {
    inputPrefixCls: 'ant-input',
    prefixCls: 'ant-input-search',
    enterButton: false
};

/***/ }),
/* 615 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_omit_js__ = __webpack_require__(138);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_react_lifecycles_compat__ = __webpack_require__(61);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_resize_observer_polyfill__ = __webpack_require__(341);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__calculateNodeHeight__ = __webpack_require__(616);

var TextArea = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(TextArea, _React$Component);

function TextArea() {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, TextArea);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (TextArea.__proto__ || Object.getPrototypeOf(TextArea)).apply(this, arguments));

_this.state = {
            textareaStyles: {}
        };
        _this.resizeOnNextFrame = function () {
            if (_this.nextFrameActionId) {
                clearNextFrameAction(_this.nextFrameActionId);
            }
            _this.nextFrameActionId = onNextFrame(_this.resizeTextarea);
        };
        _this.resizeTextarea = function () {
            var autosize = _this.props.autosize;

if (!autosize || !_this.textAreaRef) {
                return;
            }
            var minRows = autosize ? autosize.minRows : null;
            var maxRows = autosize ? autosize.maxRows : null;
            var textareaStyles = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_11__calculateNodeHeight__["a" /* default */])(_this.textAreaRef, false, minRows, maxRows);
            _this.setState({ textareaStyles: textareaStyles });
        };
        _this.handleTextareaChange = function (e) {
            if (!('value' in _this.props)) {
                _this.resizeTextarea();
            }
            var onChange = _this.props.onChange;

if (onChange) {
                onChange(e);
            }
        };
        _this.handleKeyDown = function (e) {
            var _this$props = _this.props,
                onPressEnter = _this$props.onPressEnter,
                onKeyDown = _this$props.onKeyDown;

if (e.keyCode === 13 && onPressEnter) {
                onPressEnter(e);
            }
            if (onKeyDown) {
                onKeyDown(e);
            }
        };
        _this.saveTextAreaRef = function (textArea) {
            _this.textAreaRef = textArea;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(TextArea, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
            this.resizeTextarea();
            this.updateResizeObserverHook();
        }
    }, {
        key: 'componentDidUpdate',
        value: function componentDidUpdate(prevProps) {
            // Re-render with the new content then recalculate the height as required.
            if (prevProps.value !== this.props.value) {
                this.resizeOnNextFrame();
            }
            this.updateResizeObserverHook();
        }
    }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            if (this.resizeObserver) {
                this.resizeObserver.disconnect();
            }
        }
        // We will update hooks if `autosize` prop change

}, {
        key: 'updateResizeObserverHook',
        value: function updateResizeObserverHook() {
            if (!this.resizeObserver && this.props.autosize) {
                // Add resize observer
                this.resizeObserver = new __WEBPACK_IMPORTED_MODULE_10_resize_observer_polyfill__["default"](this.resizeOnNextFrame);
                this.resizeObserver.observe(this.textAreaRef);
            } else if (this.resizeObserver && !this.props.autosize) {
                // Remove resize observer
                this.resizeObserver.disconnect();
                this.resizeObserver = null;
            }
        }
    }, {
        key: 'focus',
        value: function focus() {
            this.textAreaRef.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.textAreaRef.blur();
        }
    }, {
        key: 'getTextAreaClassName',
        value: function getTextAreaClassName() {
            var _props = this.props,
                prefixCls = _props.prefixCls,
                className = _props.className,
                disabled = _props.disabled;

return __WEBPACK_IMPORTED_MODULE_8_classnames___default()(prefixCls, className, __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()({}, prefixCls + '-disabled', disabled));
        }
    }, {
        key: 'render',
        value: function render() {
            var props = this.props;
            var otherProps = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7_omit_js__["a" /* default */])(props, ['prefixCls', 'onPressEnter', 'autosize']);
            var style = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, props.style, this.state.textareaStyles);
            // Fix https://github.com/ant-design/ant-design/issues/6776
            // Make sure it could be reset when using form.getFieldDecorator
            if ('value' in otherProps) {
                otherProps.value = otherProps.value || '';
            }
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]('textarea', __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, otherProps, { className: this.getTextAreaClassName(), style: style, onKeyDown: this.handleKeyDown, onChange: this.handleTextareaChange, ref: this.saveTextAreaRef }));
        }
    }]);

return TextArea;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

TextArea.defaultProps = {
    prefixCls: 'ant-input'
};
__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9_react_lifecycles_compat__["polyfill"])(TextArea);
/* harmony default export */ __webpack_exports__["a"] = (TextArea);

/***/ }),
/* 616 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = calculateNodeHeight;
// Thanks to https://github.com/andreypopp/react-textarea-autosize/
/**
 * calculateNodeHeight(uiTextNode, useCache = false)
 */
var HIDDEN_TEXTAREA_STYLE = '\n  min-height:0 !important;\n  max-height:none !important;\n  height:0 !important;\n  visibility:hidden !important;\n  overflow:hidden !important;\n  position:absolute !important;\n  z-index:-1000 !important;\n  top:0 !important;\n  right:0 !important\n';
var SIZING_STYLE = ['letter-spacing', 'line-height', 'padding-top', 'padding-bottom', 'font-family', 'font-weight', 'font-size', 'text-rendering', 'text-transform', 'width', 'text-indent', 'padding-left', 'padding-right', 'border-width', 'box-sizing'];
var computedStyleCache = {};
var hiddenTextarea = void 0;
function calculateNodeStyling(node) {
    var useCache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

if (!hiddenTextarea) {
        hiddenTextarea = document.createElement('textarea');
        document.body.appendChild(hiddenTextarea);
    }
    // Fix wrap="off" issue
    // https://github.com/ant-design/ant-design/issues/6577
    if (uiTextNode.getAttribute('wrap')) {
        hiddenTextarea.setAttribute('wrap', uiTextNode.getAttribute('wrap'));
    } else {
        hiddenTextarea.removeAttribute('wrap');
    }
    // Copy all CSS properties that have an impact on the height of the content in
    // the textbox

var _calculateNodeStyling = calculateNodeStyling(uiTextNode, useCache),
        paddingSize = _calculateNodeStyling.paddingSize,
        borderSize = _calculateNodeStyling.borderSize,
        boxSizing = _calculateNodeStyling.boxSizing,
        sizingStyle = _calculateNodeStyling.sizingStyle;
    // Need to have the overflow attribute to hide the scrollbar otherwise
    // text-lines will not calculated properly as the shadow will technically be
    // narrower for content

hiddenTextarea.setAttribute('style', sizingStyle + ';' + HIDDEN_TEXTAREA_STYLE);
    hiddenTextarea.value = uiTextNode.value || uiTextNode.placeholder || '';
    var minHeight = Number.MIN_SAFE_INTEGER;
    var maxHeight = Number.MAX_SAFE_INTEGER;
    var height = hiddenTextarea.scrollHeight;
    var overflowY = void 0;
    if (boxSizing === 'border-box') {
        // border-box: add border, since height = content + padding + border
        height = height + borderSize;
    } else if (boxSizing === 'content-box') {
        // remove padding, since height = content
        height = height - paddingSize;
    }
    if (minRows !== null || maxRows !== null) {
        // measure height of a textarea with a single row
        hiddenTextarea.value = ' ';
        var singleRowHeight = hiddenTextarea.scrollHeight - paddingSize;
        if (minRows !== null) {
            minHeight = singleRowHeight * minRows;
            if (boxSizing === 'border-box') {
                minHeight = minHeight + paddingSize + borderSize;
            }
            height = Math.max(minHeight, height);
        }
        if (maxRows !== null) {
            maxHeight = singleRowHeight * maxRows;
            if (boxSizing === 'border-box') {
                maxHeight = maxHeight + paddingSize + borderSize;
            }
            overflowY = height > maxHeight ? '' : 'hidden';
            height = Math.min(maxHeight, height);
        }
    }
    return { height: height, minHeight: minHeight, maxHeight: maxHeight, overflowY: overflowY };
}

/***/ }),
/* 617 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rc_menu__ = __webpack_require__(140);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__tooltip__ = __webpack_require__(58);

var MenuItem = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(MenuItem, _React$Component);

function MenuItem() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, MenuItem);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (MenuItem.__proto__ || Object.getPrototypeOf(MenuItem)).apply(this, arguments));

_this.onKeyDown = function (e) {
            _this.menuItem.onKeyDown(e);
        };
        _this.saveMenuItem = function (menuItem) {
            _this.menuItem = menuItem;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(MenuItem, [{
        key: 'render',
        value: function render() {
            var inlineCollapsed = this.context.inlineCollapsed;
            var _props = this.props,
                level = _props.level,
                children = _props.children,
                rootPrefixCls = _props.rootPrefixCls;
            var _a = this.props,
                title = _a.title,
                rest = __rest(_a, ["title"]);
            var titleNode = void 0;
            if (inlineCollapsed) {
                titleNode = title || (level === 1 ? children : '');
            }
            return __WEBPACK_IMPORTED_MODULE_5_react__["createElement"](
                __WEBPACK_IMPORTED_MODULE_8__tooltip__["default"],
                { title: titleNode, placement: 'right', overlayClassName: rootPrefixCls + '-inline-collapsed-tooltip' },
                __WEBPACK_IMPORTED_MODULE_5_react__["createElement"](__WEBPACK_IMPORTED_MODULE_6_rc_menu__["a" /* Item */], __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, rest, { title: inlineCollapsed ? null : title, ref: this.saveMenuItem }))
            );
        }
    }]);

return MenuItem;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

MenuItem.contextTypes = {
    inlineCollapsed: __WEBPACK_IMPORTED_MODULE_7_prop_types__["bool"]
};
MenuItem.isMenuItem = 1;
/* harmony default export */ __webpack_exports__["a"] = (MenuItem);

/***/ }),
/* 618 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rc_menu__ = __webpack_require__(140);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_classnames__);

var SubMenu = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(SubMenu, _React$Component);

function SubMenu() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, SubMenu);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (SubMenu.__proto__ || Object.getPrototypeOf(SubMenu)).apply(this, arguments));

_this.onKeyDown = function (e) {
            _this.subMenu.onKeyDown(e);
        };
        _this.saveSubMenu = function (subMenu) {
            _this.subMenu = subMenu;
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(SubMenu, [{
        key: 'render',
        value: function render() {
            var _props = this.props,
                rootPrefixCls = _props.rootPrefixCls,
                className = _props.className;

var theme = this.context.antdMenuTheme;
            return __WEBPACK_IMPORTED_MODULE_5_react__["createElement"](__WEBPACK_IMPORTED_MODULE_7_rc_menu__["e" /* SubMenu */], __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, this.props, { ref: this.saveSubMenu, popupClassName: __WEBPACK_IMPORTED_MODULE_8_classnames___default()(rootPrefixCls + '-' + theme, className) }));
        }
    }]);

return SubMenu;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

SubMenu.contextTypes = {
    antdMenuTheme: __WEBPACK_IMPORTED_MODULE_6_prop_types__["string"]
};
// fix issue:https://github.com/ant-design/ant-design/issues/8666
SubMenu.isSubMenu = 1;
/* harmony default export */ __webpack_exports__["a"] = (SubMenu);

/***/ }),
/* 619 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var ActionButton = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(ActionButton, _React$Component);

function ActionButton(props) {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, ActionButton);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (ActionButton.__proto__ || Object.getPrototypeOf(ActionButton)).call(this, props));

_this.onClick = function () {
            var _this$props = _this.props,
                actionFn = _this$props.actionFn,
                closeModal = _this$props.closeModal;

if (actionFn) {
                var ret = void 0;
                if (actionFn.length) {
                    ret = actionFn(closeModal);
                } else {
                    ret = actionFn();
                    if (!ret) {
                        closeModal();
                    }
                }
                if (ret && ret.then) {
                    _this.setState({ loading: true });
                    ret.then(function () {
                        // It's unnecessary to set loading=false, for the Modal will be unmounted after close.
                        // this.setState({ loading: false });
                        closeModal.apply(undefined, arguments);
                    }, function () {
                        // See: https://github.com/ant-design/ant-design/issues/6183
                        _this.setState({ loading: false });
                    });
                }
            } else {
                closeModal();
            }
        };
        _this.state = {
            loading: false
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(ActionButton, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
            if (this.props.autoFocus) {
                var $this = __WEBPACK_IMPORTED_MODULE_6_react_dom__["findDOMNode"](this);
                this.timeoutId = setTimeout(function () {
                    return $this.focus();
                });
            }
        }
    }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            clearTimeout(this.timeoutId);
        }
    }, {
        key: 'render',
        value: function render() {
            var _props = this.props,
                type = _props.type,
                children = _props.children,
                buttonProps = _props.buttonProps;

var loading = this.state.loading;
            return __WEBPACK_IMPORTED_MODULE_5_react__["createElement"](
                __WEBPACK_IMPORTED_MODULE_7__button__["default"],
                __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ type: type, onClick: this.onClick, loading: loading }, buttonProps),
                children
            );
        }
    }]);

return ActionButton;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (ActionButton);

/***/ }),
/* 620 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = confirm;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__icon__ = __webpack_require__(52);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__Modal__ = __webpack_require__(350);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__ActionButton__ = __webpack_require__(619);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__locale__ = __webpack_require__(351);

var _this = this;

var IS_REACT_16 = !!__WEBPACK_IMPORTED_MODULE_3_react_dom__["createPortal"];
var ConfirmDialog = function ConfirmDialog(props) {
    var onCancel = props.onCancel,
        onOk = props.onOk,
        close = props.close,
        zIndex = props.zIndex,
        afterClose = props.afterClose,
        visible = props.visible,
        keyboard = props.keyboard,
        centered = props.centered,
        getContainer = props.getContainer,
        maskStyle = props.maskStyle,
        okButtonProps = props.okButtonProps,
        cancelButtonProps = props.cancelButtonProps;

currentConfig = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, currentConfig, { visible: false, afterClose: destroy.bind.apply(destroy, [this].concat(args)) });
        if (IS_REACT_16) {
            render(currentConfig);
        } else {
            destroy.apply(undefined, args);
        }
    }
    function update(newConfig) {
        currentConfig = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, currentConfig, newConfig);
        render(currentConfig);
    }
    function destroy() {
        var unmountResult = __WEBPACK_IMPORTED_MODULE_3_react_dom__["unmountComponentAtNode"](div);
        if (unmountResult && div.parentNode) {
            div.parentNode.removeChild(div);
        }

for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
        }

/***/ }),
/* 621 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_shallowequal__ = __webpack_require__(115);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_shallowequal___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_shallowequal__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__radio__ = __webpack_require__(208);

var RadioGroup = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(RadioGroup, _React$Component);

function RadioGroup(props) {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, RadioGroup);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (RadioGroup.__proto__ || Object.getPrototypeOf(RadioGroup)).call(this, props));

_this.onRadioChange = function (ev) {
            var lastValue = _this.state.value;
            var value = ev.target.value;

if (!('value' in _this.props)) {
                _this.setState({
                    value: value
                });
            }
            var onChange = _this.props.onChange;
            if (onChange && value !== lastValue) {
                onChange(ev);
            }
        };
        var value = void 0;
        if ('value' in props) {
            value = props.value;
        } else if ('defaultValue' in props) {
            value = props.defaultValue;
        } else {
            var checkedValue = getCheckedValue(props.children);
            value = checkedValue && checkedValue.value;
        }
        _this.state = {
            value: value
        };
        return _this;
    }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(RadioGroup, [{
        key: 'getChildContext',
        value: function getChildContext() {
            return {
                radioGroup: {
                    onChange: this.onRadioChange,
                    value: this.state.value,
                    disabled: this.props.disabled,
                    name: this.props.name
                }
            };
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            if ('value' in nextProps) {
                this.setState({
                    value: nextProps.value
                });
            } else {
                var checkedValue = getCheckedValue(nextProps.children);
                if (checkedValue) {
                    this.setState({
                        value: checkedValue.value
                    });
                }
            }
        }
    }, {
        key: 'shouldComponentUpdate',
        value: function shouldComponentUpdate(nextProps, nextState) {
            return !__WEBPACK_IMPORTED_MODULE_8_shallowequal___default()(this.props, nextProps) || !__WEBPACK_IMPORTED_MODULE_8_shallowequal___default()(this.state, nextState);
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

var props = this.props;
            var prefixCls = props.prefixCls,
                _props$className = props.className,
                className = _props$className === undefined ? '' : _props$className,
                options = props.options,
                buttonStyle = props.buttonStyle;

return RadioGroup;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (RadioGroup);

RadioGroup.defaultProps = {
    disabled: false,
    prefixCls: 'ant-radio',
    buttonStyle: 'outline'
};
RadioGroup.childContextTypes = {
    radioGroup: __WEBPACK_IMPORTED_MODULE_6_prop_types__["any"]
};

/***/ }),
/* 622 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__radio__ = __webpack_require__(208);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__group__ = __webpack_require__(621);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__radioButton__ = __webpack_require__(623);
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Button", function() { return __WEBPACK_IMPORTED_MODULE_2__radioButton__["a"]; });
/* harmony reexport (binding) */ __webpack_require__.d(__webpack_exports__, "Group", function() { return __WEBPACK_IMPORTED_MODULE_1__group__["a"]; });

__WEBPACK_IMPORTED_MODULE_0__radio__["a" /* default */].Button = __WEBPACK_IMPORTED_MODULE_2__radioButton__["a" /* default */];
__WEBPACK_IMPORTED_MODULE_0__radio__["a" /* default */].Group = __WEBPACK_IMPORTED_MODULE_1__group__["a" /* default */];

/* harmony default export */ __webpack_exports__["default"] = (__WEBPACK_IMPORTED_MODULE_0__radio__["a" /* default */]);

/***/ }),
/* 623 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var RadioButton = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(RadioButton, _React$Component);

function RadioButton() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, RadioButton);

return __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (RadioButton.__proto__ || Object.getPrototypeOf(RadioButton)).apply(this, arguments));
    }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(RadioButton, [{
        key: 'render',
        value: function render() {
            var radioProps = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, this.props);
            if (this.context.radioGroup) {
                radioProps.onChange = this.context.radioGroup.onChange;
                radioProps.checked = this.props.value === this.context.radioGroup.value;
                radioProps.disabled = this.props.disabled || this.context.radioGroup.disabled;
            }
            return __WEBPACK_IMPORTED_MODULE_5_react__["createElement"](__WEBPACK_IMPORTED_MODULE_7__radio__["a" /* default */], radioProps);
        }
    }]);

return RadioButton;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (RadioButton);

RadioButton.defaultProps = {
    prefixCls: 'ant-radio-button'
};
RadioButton.contextTypes = {
    radioGroup: __WEBPACK_IMPORTED_MODULE_6_prop_types__["any"]
};

/***/ }),
/* 624 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(924);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);

/***/ }),
/* 625 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rc_slider_es_Slider__ = __webpack_require__(1154);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_slider_es_Range__ = __webpack_require__(1153);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rc_slider_es_Handle__ = __webpack_require__(474);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__tooltip__ = __webpack_require__(58);

var Slider = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_inherits___default()(Slider, _React$Component);

function Slider(props) {
        __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Slider);

var _this = __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Slider.__proto__ || Object.getPrototypeOf(Slider)).call(this, props));

_this.toggleTooltipVisible = function (index, visible) {
            _this.setState(function (_ref) {
                var visibles = _ref.visibles;
                return {
                    visibles: __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, visibles, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()({}, index, visible))
                };
            });
        };
        _this.handleWithTooltip = function (_a) {
            var value = _a.value,
                dragging = _a.dragging,
                index = _a.index,
                restProps = __rest(_a, ["value", "dragging", "index"]);

var _this$props = _this.props,
                tooltipPrefixCls = _this$props.tooltipPrefixCls,
                tipFormatter = _this$props.tipFormatter,
                tooltipVisible = _this$props.tooltipVisible;
            var visibles = _this.state.visibles;

__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_createClass___default()(Slider, [{
        key: 'focus',
        value: function focus() {
            this.rcSlider.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.rcSlider.blur();
        }
    }, {
        key: 'render',
        value: function render() {
            var _a = this.props,
                range = _a.range,
                restProps = __rest(_a, ["range"]);
            if (range) {
                return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_8_rc_slider_es_Range__["a" /* default */], __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, restProps, { ref: this.saveSlider, handle: this.handleWithTooltip }));
            }
            return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_7_rc_slider_es_Slider__["a" /* default */], __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, restProps, { ref: this.saveSlider, handle: this.handleWithTooltip }));
        }
    }]);

return Slider;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

/* harmony default export */ __webpack_exports__["default"] = (Slider);

Slider.defaultProps = {
    prefixCls: 'ant-slider',
    tooltipPrefixCls: 'ant-tooltip',
    tipFormatter: function tipFormatter(value) {
        return value.toString();
    }
};

/***/ }),
/* 626 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less__ = __webpack_require__(35);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__style_index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__style_index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less__ = __webpack_require__(926);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__index_less___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__index_less__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__tooltip_style__ = __webpack_require__(59);

// style dependencies

/***/ }),
/* 627 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export getOverflowOptions */
/* harmony export (immutable) */ __webpack_exports__["a"] = getPlacements;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_rc_tooltip_es_placements__ = __webpack_require__(477);

/***/ }),
/* 628 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// rawAsap provides everything we need except exception management.
var rawAsap = __webpack_require__(629);
// RawTasks are recycled to reduce GC churn.
var freeTasks = [];
// We queue errors to ensure they are thrown in right order (FIFO).
// Array-as-queue is good enough here, since we are just dealing with exceptions.
var pendingErrors = [];
var requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);

function throwFirstError() {
    if (pendingErrors.length) {
        throw pendingErrors.shift();
    }
}

/**
 * Calls a task as soon as possible after returning, in its own event, with priority
 * over other events like animation, reflow, and repaint. An error thrown from an
 * event will not interrupt, nor even substantially slow down the processing of
 * other events, but will be rather postponed to a lower priority event.
 * @param {{call}} task A callable object, typically a function that takes no
 * arguments.
 */
module.exports = asap;
function asap(task) {
    var rawTask;
    if (freeTasks.length) {
        rawTask = freeTasks.pop();
    } else {
        rawTask = new RawTask();
    }
    rawTask.task = task;
    rawAsap(rawTask);
}

// We wrap tasks with recyclable task objects.  A task object implements
// `call`, just like a function.
function RawTask() {
    this.task = null;
}

// The sole purpose of wrapping the task is to catch the exception and recycle
// the task object after its single use.
RawTask.prototype.call = function () {
    try {
        this.task.call();
    } catch (error) {
        if (asap.onerror) {
            // This hook exists purely for testing purposes.
            // Its name will be periodically randomized to break any code that
            // depends on its existence.
            asap.onerror(error);
        } else {
            // In a web browser, exceptions are not fatal. However, to avoid
            // slowing down the queue of pending tasks, we rethrow the error in a
            // lower priority turn.
            pendingErrors.push(error);
            requestErrorThrow();
        }
    } finally {
        this.task = null;
        freeTasks[freeTasks.length] = this;
    }
};

/***/ }),
/* 629 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {

// Use the fastest means possible to execute a task in its own turn, with
// priority over other events including IO, animation, reflow, and redraw
// events in browsers.
//
// An exception thrown by a task will permanently interrupt the processing of
// subsequent tasks. The higher level `asap` function ensures that if an
// exception is thrown by a task, that the task queue will continue flushing as
// soon as possible, but if you use `rawAsap` directly, you are responsible to
// either ensure that no exceptions are thrown from your task, or to manually
// call `rawAsap.requestFlush` if an exception is thrown.
module.exports = rawAsap;
function rawAsap(task) {
    if (!queue.length) {
        requestFlush();
        flushing = true;
    }
    // Equivalent to push, but avoids a function call.
    queue[queue.length] = task;
}

var queue = [];
// Once a flush has been requested, no further calls to `requestFlush` are
// necessary until the next `flush` completes.
var flushing = false;
// `requestFlush` is an implementation-specific method that attempts to kick
// off a `flush` event as quickly as possible. `flush` will attempt to exhaust
// the event queue before yielding to the browser's own event loop.
var requestFlush;
// The position of the next task to execute in the task queue. This is
// preserved between calls to `flush` so that it can be resumed if
// a task throws an exception.
var index = 0;
// If a task schedules additional tasks recursively, the task queue can grow
// unbounded. To prevent memory exhaustion, the task queue will periodically
// truncate already-completed tasks.
var capacity = 1024;

// The flush function processes all tasks that have been scheduled with
// `rawAsap` unless and until one of those tasks throws an exception.
// If a task throws an exception, `flush` ensures that its state will remain
// consistent and will resume where it left off when called again.
// However, `flush` does not make any arrangements to be called again if an
// exception is thrown.
function flush() {
    while (index < queue.length) {
        var currentIndex = index;
        // Advance the index before calling the task. This ensures that we will
        // begin flushing on the next task the task throws an error.
        index = index + 1;
        queue[currentIndex].call();
        // Prevent leaking memory for long chains of recursive calls to `asap`.
        // If we call `asap` within tasks scheduled by `asap`, the queue will
        // grow, but to avoid an O(n) walk for every task we execute, we don't
        // shift tasks off the queue after they have been executed.
        // Instead, we periodically shift 1024 tasks off the queue.
        if (index > capacity) {
            // Manually shift all values starting at the index back to the
            // beginning of the queue.
            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
                queue[scan] = queue[scan + index];
            }
            queue.length -= index;
            index = 0;
        }
    }
    queue.length = 0;
    index = 0;
    flushing = false;
}

// `requestFlush` is implemented using a strategy based on data collected from
// every available SauceLabs Selenium web driver worker at time of writing.
// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593

// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that
// have WebKitMutationObserver but not un-prefixed MutationObserver.
// Must use `global` or `self` instead of `window` to work in both frames and web
// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.

/* globals self */
var scope = typeof global !== "undefined" ? global : self;
var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;

// MutationObservers are desirable because they have high priority and work
// reliably everywhere they are implemented.
// They are implemented in all modern browsers.
//
// - Android 4-4.3
// - Chrome 26-34
// - Firefox 14-29
// - Internet Explorer 11
// - iPad Safari 6-7.1
// - iPhone Safari 7-7.1
// - Safari 6-7
if (typeof BrowserMutationObserver === "function") {
    requestFlush = makeRequestCallFromMutationObserver(flush);

// MessageChannels are desirable because they give direct access to the HTML
// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
// 11-12, and in web workers in many engines.
// Although message channels yield to any queued rendering and IO tasks, they
// would be better than imposing the 4ms delay of timers.
// However, they do not work reliably in Internet Explorer or Safari.

// Internet Explorer 10 is the only browser that has setImmediate but does
// not have MutationObservers.
// Although setImmediate yields to the browser's renderer, it would be
// preferrable to falling back to setTimeout since it does not have
// the minimum 4ms penalty.
// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
// Desktop to a lesser extent) that renders both setImmediate and
// MessageChannel useless for the purposes of ASAP.
// https://github.com/kriskowal/q/issues/396

// Timers are implemented universally.
// We fall back to timers in workers in most engines, and in foreground
// contexts in the following browsers.
// However, note that even this simple case requires nuances to operate in a
// broad spectrum of browsers.
//
// - Firefox 3-13
// - Internet Explorer 6-9
// - iPad Safari 4.3
// - Lynx 2.8.7
} else {
    requestFlush = makeRequestCallFromTimer(flush);
}

// `requestFlush` requests that the high priority event queue be flushed as
// soon as possible.
// This is useful to prevent an error thrown in a task from stalling the event
// queue if the exception handled by Node.js’s
// `process.on("uncaughtException")` or by a domain.
rawAsap.requestFlush = requestFlush;

// To request a high priority event, we induce a mutation observer by toggling
// the text of a text node between "1" and "-1".
function makeRequestCallFromMutationObserver(callback) {
    var toggle = 1;
    var observer = new BrowserMutationObserver(callback);
    var node = document.createTextNode("");
    observer.observe(node, {characterData: true});
    return function requestCall() {
        toggle = -toggle;
        node.data = toggle;
    };
}

// The message channel technique was discovered by Malte Ubl and was the
// original foundation for this library.
// http://www.nonblocking.io/2011/06/windownexttick.html

// Safari 6.0.5 (at least) intermittently fails to create message ports on a
// page's first load. Thankfully, this version of Safari supports
// MutationObservers, so we don't need to fall back in that case.

// function makeRequestCallFromMessageChannel(callback) {
//     var channel = new MessageChannel();
//     channel.port1.onmessage = callback;
//     return function requestCall() {
//         channel.port2.postMessage(0);
//     };
// }

// For reasons explained above, we are also unable to use `setImmediate`
// under any circumstances.
// Even if we were, there is another bug in Internet Explorer 10.
// It is not sufficient to assign `setImmediate` to `requestFlush` because
// `setImmediate` must be called *by name* and therefore must be wrapped in a
// closure.
// Never forget.

// function makeRequestCallFromSetImmediate(callback) {
//     return function requestCall() {
//         setImmediate(callback);
//     };
// }

// Safari 6.0 has a problem where timers will get lost while the user is
// scrolling. This problem does not impact ASAP because Safari 6.0 supports
// mutation observers, so that implementation is used instead.
// However, if we ever elect to use timers in Safari, the prevalent work-around
// is to add a scroll event listener that calls for a flush.

// `setTimeout` does not call the passed callback if the delay is less than
// approximately 7 in web workers in Firefox 8 through 18, and sometimes not
// even then.

function makeRequestCallFromTimer(callback) {
    return function requestCall() {
        // We dispatch a timeout with a specified delay of 0 for engines that
        // can reliably accommodate that request. This will usually be snapped
        // to a 4 milisecond delay, but once we're flushing, there's no delay
        // between events.
        var timeoutHandle = setTimeout(handleTimer, 0);
        // However, since this timer gets frequently dropped in Firefox
        // workers, we enlist an interval handle that will try to fire
        // an event 20 times per second until it succeeds.
        var intervalHandle = setInterval(handleTimer, 50);

function handleTimer() {
            // Whichever timer succeeds will cancel both timers and
            // execute the callback.
            clearTimeout(timeoutHandle);
            clearInterval(intervalHandle);
            callback();
        }
    };
}

// This is for `asap.js` only.
// Its name will be periodically randomized to break any code that depends on
// its existence.
rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;

// ASAP was originally a nextTick shim included in Q. This was factored out
// into this ASAP package. It was later adapted to RSVP which made further
// amendments. These decisions, particularly to marginalize MessageChannel and
// to capture the MutationObserver implementation in a closure, were integrated
// back into ASAP proper.
// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 630 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var GlobalSettings = __webpack_require__(675).default,
    addInlineEditorEvents = __webpack_require__(32).addEditorListeners,
    openDrawer = __webpack_require__(2).openDrawer,
    ReactSlick = __webpack_require__(882).default,
    closeDrawer = __webpack_require__(2).closeDrawer,
    loadFooterPresets = __webpack_require__(2).loadFooterPresets,
    loadHeaderRowPresets = __webpack_require__(2).loadHeaderRowPresets,
    loadSectionPresets = __webpack_require__(2).loadSectionPresets,
    copyPasteFunctionalityAdder = __webpack_require__(690),
    addModule = __webpack_require__(2).addModule,
    BirdsEyeViewList = __webpack_require__(214).default,
    getElementFromRoutePath = __webpack_require__(368),
    addKeyBoardShortcuts = __webpack_require__(685),
    setDragPlaceholder = __webpack_require__(2).setDragPlaceholder,
    resetDragPlaceholder = __webpack_require__(2).resetDragPlaceholder,
    ModuleListWrapper = __webpack_require__(357),
    ModuleEditorWrapper = __webpack_require__(666),
    IndexRoute = __webpack_require__(40).IndexRoute,
    Router = __webpack_require__(40).Router,
    DrawerWrapper = __webpack_require__(631),
    Route = __webpack_require__(40).Route,
    RightPanel = __webpack_require__(230),
    HTML5Backend = __webpack_require__(304),
    flow = __webpack_require__(60),
    dndPageScroll = __webpack_require__(121),
    DragDropContext = __webpack_require__(37).DragDropContext,
    BottomToolBar = __webpack_require__(639).default,
    browserHistory = __webpack_require__(40).browserHistory,
    store = __webpack_require__(11),
    Revisions = __webpack_require__(678),
    InputPanel = __webpack_require__(667);
__webpack_require__(884);
// just to expose it to exp modules
console.log(ReactSlick);
var App = React.createClass({
    displayName: 'App',

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        if (!this.props.state.initialState.get('frameLoaded') && nextProps.state.initialState.get('frameLoaded')) {
            var iframeDocument = document.getElementById('tatsu-preview').contentDocument,
                tatsuOverlay = iframeDocument.getElementById('tatsu-modulelist-drawer-overlay');
            if (iframeDocument) {
                addKeyBoardShortcuts(iframeDocument);
                copyPasteFunctionalityAdder(iframeDocument);
                addInlineEditorEvents();
                if (tatsuOverlay) {
                    tatsuOverlay.addEventListener('click', function (event) {
                        store.dispatch(closeDrawer());
                    });
                }
            }
        }
    },

removePreview: function removePreview() {

var initialPreview = document.getElementsByClassName('tatsu-load-preview-wrapper');
        if (0 < initialPreview.length) {
            document.getElementsByClassName('tatsu-load-preview-wrapper')[0].style.display = 'none';
        }
    },

componentDidMount: function componentDidMount() {
        var iframeDocument = document.getElementById('tatsu-preview').contentDocument,
            builderMode = this.props.state.builderMode,
            sections = this.props.state.tatsu_page_content.getIn(['present', 'inner']),
            fixedScrollBar = iframeDocument.getElementsByClassName('simplebar');

if (0 < fixedScrollBar.length) {
            fixedScrollBar = fixedScrollBar[0];
            if (null != fixedScrollBar && 'undefined' != typeof fixedScrollBar) {
                fixedScrollBar.addEventListener('scroll', function (event) {
                    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
                });
            }
        }
        window.addEventListener('message', function (event) {
            var messageArray = event.data.toString().split(' ');
            switch (messageArray[0]) {

case 'addModule':
                    var path = Immutable.List(JSON.parse("[" + messageArray[1].replace(/-/g, ',') + "]")),
                        position = messageArray[2],
                        meta = Immutable.Map({
                        path: path,
                        position: position,
                        addType: 'insert'
                    });
                    store.dispatch(openDrawer('modulelist', meta));
                    break;

case 'addSection':
                    var path = Immutable.List(JSON.parse("[" + messageArray[1].replace(/-/g, ',') + "]")),
                        position = messageArray[2];
                    store.dispatch(closeDrawer());
                    store.dispatch(addModule(path, 'tatsu_section', 'insert', position));
                    break;

case 'setDrag':
                    var path = Immutable.List(JSON.parse("[" + messageArray[1].replace(/-/g, ',') + "]")),
                        position = messageArray[2];
                    store.dispatch(setDragPlaceholder(path, position));
                    break;

case 'resetDrag':
                    store.dispatch(resetDragPlaceholder());
                    break;
                default:
                    break;

}
            return;
        });
        if ('header_builder' === builderMode) {
            store.dispatch(loadHeaderRowPresets());
        } else if ('footer_builder' === builderMode) {
            store.dispatch(loadFooterPresets());
        } else {
            store.dispatch(loadSectionPresets());
        }
        if (sections.size === 0) {
            if ('header_builder' === builderMode) {
                store.dispatch(addModule(Immutable.List(), 'tatsu_header_row', 'push'));
            } else {
                store.dispatch(addModule(Immutable.List(), 'tatsu_section', 'push'));
            }
        }
        store.dispatch({ type: 'SET_CURRENT_SAVE_STATE', sectionList: sections });
        dndPageScroll.init();
        this.removePreview();
    },

renderHelper: function renderHelper() {

if (window.tatsuConfig.revision_data) {
                return React.createElement(Revisions, {
                    revisionHelper: this.props.state.revisionHelper
                });
            } else {
                return React.createElement(
                    'div',
                    { className: 'be-pb-revisions-not-available' },
                    'Sorry! Revisions are not available.',
                    React.createElement(
                        'div',
                        { className: 'be-pb-revisions-not-available-desc' },
                        'Kindly check whether revisions are enabled in your WordPress installation'
                    )
                );
            }
        };

return React.createElement(
            'div',
            { className: 'container' },
            React.createElement(
                Router,
                { history: browserHistory },
                React.createElement(
                    Route,
                    { path: window.location.pathname, component: InputPanelWrapper.bind(this) },
                    React.createElement(IndexRoute, { component: LayoutWrapper.bind(this) }),
                    React.createElement(Route, { path: 'layoutManager/(:modulePath)', component: LayoutWrapper.bind(this) }),
                    React.createElement(Route, { path: 'moduleList', component: ModuleListOuterWrapper.bind(this) }),
                    React.createElement(Route, { path: 'moduleEditor/(:modulePath)/(:moduleId)', component: ModuleWrapper.bind(this) }),
                    React.createElement(Route, { path: 'globalSettings', component: GlobalSettingsWrapper.bind(this) }),
                    React.createElement(Route, { path: 'tatsuRevisions', component: RevisionsWrapper.bind(this) })
                )
            )
        );
    },

render: function render() {
        return this.renderHelper();
    }
});

module.exports = flow(DragDropContext(HTML5Backend))(App);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 631 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var Drawer = __webpack_require__(632).default,
    SaveTemplate = __webpack_require__(636).default,
    SectionPreset = __webpack_require__(637),
    HeaderRowPreset = __webpack_require__(633),
    LoadTemplate = __webpack_require__(634),
    ModuleListWrapper = __webpack_require__(357),
    store = __webpack_require__(11),
    closeDrawer = __webpack_require__(2).closeDrawer,
    typeChecker = __webpack_require__(16);
var DrawerWrapper = React.createClass({
	displayName: 'DrawerWrapper',

_getDrawerContent: function _getDrawerContent(drawerState) {
		var currentDrawerType = drawerState.get('type'),
		    drawerMeta;
		if ('' != currentDrawerType) {
			drawerMeta = drawerState.get('meta');
		}
		if ('template' == currentDrawerType) {
			if ('save' == drawerMeta.get('action')) {
				return React.createElement(SaveTemplate, { templateType: drawerMeta.get('saveType'), path: 'sections' == drawerMeta.get('saveType') ? drawerMeta.get('path') : null });
			} else if ('load' == drawerMeta.get('action')) {
				return React.createElement(LoadTemplate, { templateState: this.props.templateState });
			}
		} else if ('preset' == currentDrawerType) {
			//To do: Make the sectionPreset a generic component so that the presets of other modules can be handled in the future!!
			if (this.props.builderMode == 'header_builder') {
				return React.createElement(HeaderRowPreset, { drawerMeta: drawerMeta, headerRowPresets: this.props.headerRowPresets });
			} else {
				return React.createElement(SectionPreset, { templatesData: this.props.templateState, drawerMeta: drawerMeta, sectionPresets: this.props.sectionPresets });
			}
		} else if ('modulelist' == currentDrawerType) {
			return React.createElement(ModuleListWrapper, { builderMode: this.props.builderMode, drawerMeta: drawerMeta, draggable: false, moduleOptions: this.props.moduleOptions });
		} else {
			return null;
		}
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

return !(Immutable.is(this.props.drawerState, nextProps.drawerState) && Immutable.is(this.props.sectionPresets, nextProps.sectionPresets) && Immutable.is(this.props.headerRowPresets, nextProps.headerRowPresets) && Immutable.is(this.props.templateState, nextProps.templateState));
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

if ('modulelist' != this.props.drawerState.get('type') && 'modulelist' == nextProps.drawerState.get('type')) {
			document.getElementById('tatsu-preview').contentDocument.getElementById('tatsu-modulelist-drawer-overlay').className = "active";
			document.getElementById('tatsu-preview').contentDocument.body.className += ' disable-add-tools';
		} else if ('modulelist' == this.props.drawerState.get('type') && 'modulelist' != nextProps.drawerState.get('type')) {
			document.getElementById('tatsu-preview').contentDocument.getElementById('tatsu-modulelist-drawer-overlay').className = "";
			document.getElementById('tatsu-preview').contentDocument.body.className = document.getElementById('tatsu-preview').contentDocument.body.className.replace(' disable-add-tools', '');
		}
	},

handleClose: function handleClose(event) {

store.dispatch(closeDrawer());
	},

render: function render() {
		var drawerState = this.props.drawerState,
		    drawerType = drawerState.get('type'),
		    disableOverlay = false;

if ('preset' == drawerType) {
			disableOverlay = true;
		}
		return React.createElement(
			Drawer,
			{ className: 'tatsu-drawer-wrapper', disableOverlay: disableOverlay, handleClose: this.handleClose, placement: 'left', open: drawerState.get('open'), duration: 450 },
			React.createElement(
				'div',
				{ className: 'tatsu-scroll-hide-outer-wrap' },
				React.createElement(
					'div',
					{ className: 'tatsu-scroll-hide-middle-wrap' },
					React.createElement(
						'div',
						{ className: 'tatsu-scroll-hide-inner-wrap' },
						React.createElement(
							'div',
							{ id: 'tatsu-drawer-back-btn-wrapper', onClick: this.handleClose },
							React.createElement(
								'div',
								{ className: 'tatsu-preset-back-btn' },
								React.createElement(
									'svg',
									{ className: 'tatsu-svg-icon', viewBox: '0 0 20 20' },
									React.createElement('path', { d: 'M18.271,9.212H3.615l4.184-4.184c0.306-0.306,0.306-0.801,0-1.107c-0.306-0.306-0.801-0.306-1.107,0\r L1.21,9.403C1.194,9.417,1.174,9.421,1.158,9.437c-0.181,0.181-0.242,0.425-0.209,0.66c0.005,0.038,0.012,0.071,0.022,0.109\r c0.028,0.098,0.075,0.188,0.142,0.271c0.021,0.026,0.021,0.061,0.045,0.085c0.015,0.016,0.034,0.02,0.05,0.033l5.484,5.483\r c0.306,0.307,0.801,0.307,1.107,0c0.306-0.305,0.306-0.801,0-1.105l-4.184-4.185h14.656c0.436,0,0.788-0.353,0.788-0.788\r S18.707,9.212,18.271,9.212z' })
								)
							),
							React.createElement(
								'span',
								{ className: 'tatsu-svg-help-text' },
								'Back'
							)
						),
						['preset' == drawerType ? React.createElement(
							'div',
							{ className: 'tatsu-preset-module-title-wrapper' },
							'New ' + drawerState.getIn(['meta', 'title']) || 'Module'
						) : null, 'preset' == drawerType ? React.createElement(
							'div',
							{ className: 'tatsu-preset-module-helptext-wrapper' },
							'Click on the columns to change the layout or choose a concept below'
						) : null, 'modulelist' == drawerType ? React.createElement('div', { id: 'tatsu-modulelist-drawer-overlay' }) : null, this._getDrawerContent(drawerState)]
					)
				)
			)
		);
	}

});
DrawerWrapper.propTypes = {
	drawerState: typeChecker.mapChecker,
	templateState: typeChecker.mapChecker,
	moduleOptions: typeChecker.mapChecker
};
module.exports = DrawerWrapper;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 632 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

__webpack_require__(883);

var _reactTransitionGroup = __webpack_require__(506);

var _EditorConstants = __webpack_require__(95);

var _EditorHelpers = __webpack_require__(26);

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

//const  = constants;

var BeDrawer = function (_React$Component) {
    _inherits(BeDrawer, _React$Component);

function BeDrawer(props) {
        _classCallCheck(this, BeDrawer);

var _this = _possibleConstructorReturn(this, (BeDrawer.__proto__ || Object.getPrototypeOf(BeDrawer)).call(this, props));

_this.validateWidth = _this.validateWidth.bind(_this);
        _this.getClassNames = _this.getClassNames.bind(_this);
        return _this;
    }

_createClass(BeDrawer, [{
        key: 'getClassNames',
        value: function getClassNames(disableOverlay, placement) {
            var classes = [];
            classes.push('be-ui-component', 'be-drawer-wrap');
            if ('' != this.props.className) {
                classes.push(this.props.className);
            }
            classes.push(placement);
            classes.push(disableOverlay);
            return classes;
        }
    }, {
        key: 'validateWidth',
        value: function validateWidth(width) {
            var parsedVal = (0, _EditorHelpers.getValueAndUnit)(width);
            if (!isNaN(parsedVal.value) && -1 < _EditorConstants.validWidthUnits.indexOf(parsedVal.unit)) {
                return width;
            }
            return '300px';
        }
    }, {
        key: 'componentDidMount',
        value: function componentDidMount() {
            var _this2 = this;

if (!this.props.disableOverlay) {
                addEventListener('keyup', function (e) {
                    if (27 == e.which) {
                        if (_this2.props.open) {
                            _this2.props.handleClose();
                        }
                    }
                });
            }
        }
    }, {
        key: 'render',
        value: function render() {
            var _this3 = this;

return BeDrawer;
}(React.Component);

exports.default = BeDrawer;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 633 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var ColumnSwitch = __webpack_require__(215),
    scrollRevealBE = __webpack_require__(375),
    findDOMNode = __webpack_require__(7).findDOMNode,
    List = __webpack_require__(314).List,
    PresetBlockWrapper = __webpack_require__(353);
var HeaderRowPreset = React.createClass({
	displayName: 'HeaderRowPreset',

render: function render() {

var drawerMeta = this.props.drawerMeta,
		    rowPath = drawerMeta.get('path'),
		    row = drawerMeta.get('module'),
		    rowLayout = row.getIn(['atts', 'layout']),
		    headerRowPresetsList = this.props.headerRowPresets;

return React.createElement(
			'div',
			{ id: 'tatsu-section-preset-wrapper', style: { padding: '20px', height: '100%' } },
			React.createElement(
				'div',
				{ id: 'tatsu-preset-blank-section-wrapper' },
				'Blank Header Row'
			),
			React.createElement(
				'div',
				{ id: 'tatsu-preset-column-switch-wrapper' },
				React.createElement(ColumnSwitch, { targetLayout: rowLayout, path: rowPath })
			),
			React.createElement(PresetBlockWrapper, { presetsList: headerRowPresetsList, sectionPath: rowPath })
		);
	}

});
module.exports = HeaderRowPreset;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 634 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var typeChecker = __webpack_require__(16),
    deleteTemplate = __webpack_require__(2).deleteTemplate,
    store = __webpack_require__(11),
    _loadTemplate = __webpack_require__(2).loadTemplate;
var LoadTemplate = React.createClass({
	displayName: 'LoadTemplate',

getInitialState: function getInitialState() {

return {
			sections: '',
			templates: '',
			preBuilt: '',
			currentPrebuiltTemplate: ''
		};
	},

handleSelectChange: function handleSelectChange(templateType, event, index, value) {
		value = event.target.value;
		var stateObject = this.state;
		stateObject[templateType] = value;
		this.setState(stateObject);
	},

loadTemplate: function loadTemplate(templateType, event) {

var templateName = this.state[templateType];
		store.dispatch(_loadTemplate(templateName, templateType));
	},

_deleteTemplate: function _deleteTemplate(templateType, event) {

var templateName = this.state[templateType];
		store.dispatch(deleteTemplate(templateType, templateName));
	},

render: function render() {

var templateState = this.props.templateState,
		    sectionTemplates = templateState.get('sections'),
		    pageTemplates = templateState.get('templates'),
		    preBuiltTemplates = templateState.get('preBuilt');

var sectionTemplatesOptions = [React.createElement(
			'option',
			{ value: 'none' },
			'None'
		)],
		    pageTemplatesOptions = [React.createElement(
			'option',
			{ value: 'none' },
			'None'
		)],
		    preBuiltTemplatesOptions = [React.createElement(
			'option',
			{ value: 'none' },
			'None'
		)];

if ((typeof sectionTemplates === 'undefined' ? 'undefined' : _typeof(sectionTemplates)) === 'object') {
			sectionTemplatesOptions = sectionTemplatesOptions.concat(sectionTemplates.map(function (section) {
				return React.createElement(
					'option',
					{ value: section.get('name') },
					section.get('title')
				);
			}));
		}

if ((typeof pageTemplates === 'undefined' ? 'undefined' : _typeof(pageTemplates)) === 'object') {
			pageTemplatesOptions = pageTemplatesOptions.concat(pageTemplates.map(function (section) {
				return React.createElement(
					'option',
					{ value: section.get('name') },
					section.get('title')
				);
			}));
		}

if ((typeof preBuiltTemplates === 'undefined' ? 'undefined' : _typeof(preBuiltTemplates)) === 'object') {
			preBuiltTemplatesOptions = preBuiltTemplatesOptions.concat(preBuiltTemplates.map(function (section) {
				return React.createElement(
					'option',
					{ value: section.get('name') },
					section.get('title')
				);
			}));
		}

return React.createElement(
			'div',
			{ className: 'be-pb-load-template-wrapper' },
			React.createElement(
				'div',
				{ className: 'be-pb-section-template-wrapper' },
				React.createElement(
					'h3',
					{ className: 'be-pb-section-templates-title' },
					' Section Templates '
				),
				React.createElement(
					'select',
					{ value: this.state.sections, style: { fontSize: '14px', marginBottom: '20px' }, id: 'section-templates', onChange: this.handleSelectChange.bind(null, 'sections') },
					sectionTemplatesOptions
				),
				this.state.sections != '' && this.state.sections !== 'none' ? React.createElement(
					'div',
					{ className: 'be-pb-template-load-options-wrapper' },
					React.createElement(
						'div',
						{ className: 'be-pb-load-template-option', onClick: this.loadTemplate.bind(null, 'sections') },
						'Load'
					),
					React.createElement(
						'div',
						{ className: 'be-pb-delete-template-option', onClick: this._deleteTemplate.bind(null, 'sections') },
						'Delete'
					)
				) : null
			),
			React.createElement(
				'div',
				{ className: 'be-pb-page-template-wrapper' },
				React.createElement(
					'h3',
					{ className: 'be-pb-page-templates-title' },
					' Page Templates '
				),
				React.createElement(
					'select',
					{ value: this.state.templates, style: { fontSize: '14px', marginBottom: '20px' }, id: 'page-templates', onChange: this.handleSelectChange.bind(null, 'templates') },
					pageTemplatesOptions
				),
				this.state.templates != '' ? React.createElement(
					'div',
					{ className: 'be-pb-template-load-options-wrapper' },
					React.createElement(
						'div',
						{ className: 'be-pb-load-template-option', onClick: this.loadTemplate.bind(null, 'templates') },
						'Load'
					),
					React.createElement(
						'div',
						{ className: 'be-pb-delete-template-option', onClick: this._deleteTemplate.bind(null, 'templates') },
						'Delete'
					)
				) : null
			),
			React.createElement(
				'div',
				{ className: 'be-pb-premium-template-wrapper' },
				React.createElement(
					'h3',
					{ className: 'be-pb-premium-templates-title' },
					' Premium Templates '
				),
				React.createElement(
					'select',
					{ value: this.state.preBuilt, style: { fontSize: '14px', marginBottom: '20px' }, id: 'prebuilt-templates', onChange: this.handleSelectChange.bind(null, 'prebuilt') },
					preBuiltTemplatesOptions
				),
				this.state.preBuilt != '' && this.state.preBuilt !== 'none' ? React.createElement(
					'div',
					{ className: 'be-pb-template-load-options-wrapper' },
					React.createElement(
						'div',
						{ className: 'be-pb-load-template-option', onClick: this.loadTemplate.bind(null, 'pre_built') },
						'Load'
					),
					React.createElement(
						'div',
						{ className: 'be-pb-delete-template-option', onClick: this._deleteTemplate.bind(null, 'prebuilt') },
						'Delete'
					)
				) : null
			)
		);
	}

});
LoadTemplate.propTypes = {
	templateState: typeChecker.mapChecker
};
module.exports = LoadTemplate;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 635 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var mapChecker = __webpack_require__(16).mapChecker,
    setPreset = __webpack_require__(2).setPreset,
    store = __webpack_require__(11),
    listChecker = __webpack_require__(16).listChecker;
var PresetBlock = React.createClass({
	displayName: 'PresetBlock',

render: function render() {

return React.createElement(
			'div',
			{ style: { height: this.props.imageHeight + 'px' }, className: "tatsu-preset-image-wrapper" + (this.props.isActive ? ' active' : ''), onClick: this.props.setActivePreset.bind(null, this.props.currentIndex) },
			React.createElement(
				'div',
				{ className: 'tatsu-preset-image-loader-wrap', style: { position: 'absolute', zIndex: '10' } },
				React.createElement(
					'svg',
					{ version: '1.0', width: '20px', height: '20px', viewBox: '0 0 128 128', xmlSpace: 'preserve' },
					React.createElement(
						'g',
						null,
						React.createElement('circle', { cx: '16', cy: '64', r: '16', fill: '#20cbd4', fillOpacity: '1' }),
						React.createElement('circle', { cx: '16', cy: '64', r: '14.344', fill: '#20cbd4', fillOpacity: '1', transform: 'rotate(45 64 64)' }),
						React.createElement('circle', { cx: '16', cy: '64', r: '12.531', fill: '#20cbd4', fillOpacity: '1', transform: 'rotate(90 64 64)' }),
						React.createElement('circle', { cx: '16', cy: '64', r: '10.75', fill: '#20cbd4', fillOpacity: '1', transform: 'rotate(135 64 64)' }),
						React.createElement('circle', { cx: '16', cy: '64', r: '10.063', fill: '#20cbd4', fillOpacity: '1', transform: 'rotate(180 64 64)' }),
						React.createElement('circle', { cx: '16', cy: '64', r: '8.063', fill: '#20cbd4', fillOpacity: '1', transform: 'rotate(225 64 64)' }),
						React.createElement('circle', { cx: '16', cy: '64', r: '6.438', fill: '#20cbd4', fillOpacity: '1', transform: 'rotate(270 64 64)' }),
						React.createElement('circle', { cx: '16', cy: '64', r: '5.375', fill: '#20cbd4', fillOpacity: '1', transform: 'rotate(315 64 64)' }),
						React.createElement('animateTransform', { attributeName: 'transform', type: 'rotate', values: '0 64 64;315 64 64;270 64 64;225 64 64;180 64 64;135 64 64;90 64 64;45 64 64', calcMode: 'discrete', dur: '720ms', repeatCount: 'indefinite' })
					)
				)
			),
			React.createElement('img', { 'data-img-source': this.props.imageSource, height: this.props.imageHeight, width: this.props.imageWidth })
		);
	}

});
module.exports = PresetBlock;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 636 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _button = __webpack_require__(149);

var _button2 = _interopRequireDefault(_button);

var _input = __webpack_require__(77);

var _input2 = _interopRequireDefault(_input);

__webpack_require__(203);

__webpack_require__(78);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var slugCreator = __webpack_require__(723),
    saveAsTemplate = __webpack_require__(2).saveAsTemplate,
    store = __webpack_require__(11),
    listChecker = __webpack_require__(16).listChecker;

var SaveTemplate = React.createClass({
	displayName: 'SaveTemplate',

getInitialState: function getInitialState() {

return {
			content: ''
		};
	},

_setContent: function _setContent(event) {

var currentContent = event.target.value;
		this.setState({
			content: currentContent
		});
	},

_handleSaveTemplate: function _handleSaveTemplate(templateType, event) {

//dispatch appropriate action!
		var title = this.state.content,
		    name = slugCreator(title),
		    path = this.props.path || Immutable.List();
		store.dispatch(saveAsTemplate(name, title, templateType, path));
	},

render: function render() {

var templateType = this.props.templateType,
		    templateLabel = templateType === 'templates' ? 'Page Template' : 'Section Template';

return React.createElement(
			'div',
			{ className: 'be-pb-save-templates-drawer-wrapper' },
			React.createElement(
				'div',
				{ className: 'be-pb-save-templates-drawer-title' },
				' ',
				templateLabel,
				' '
			),
			React.createElement(_input2.default, { inputStyle: { marginBottom: '20px' }, style: { width: '240px', marginBottom: '20px' }, value: this.state.content, onChange: this._setContent, placeholder: 'Template Name' }),
			React.createElement(
				_button2.default,
				{ type: 'primary', onClick: this._handleSaveTemplate.bind(null, templateType) },
				'Save as template'
			)
		);
	}

});
SaveTemplate.propTypes = {
	templateType: React.PropTypes.string.isRequired,
	path: listChecker
};
exports.default = SaveTemplate;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 637 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var _templatesModal = __webpack_require__(358);

var _templatesModal2 = _interopRequireDefault(_templatesModal);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ColumnSwitch = __webpack_require__(215),
    PresetBlockWrapper = __webpack_require__(353);

var SectionPreset = React.createClass({
	displayName: 'SectionPreset',

getInitialState: function getInitialState() {
		return {
			templatesModal: false
		};
	},

toggleTemplatesModal: function toggleTemplatesModal() {
		var templatesModal = this.state.templatesModal;

this.setState({
			templatesModal: !templatesModal
		});
	},

render: function render() {

var drawerMeta = this.props.drawerMeta,
		    sectionPath = drawerMeta.get('path'),
		    section = drawerMeta.get('module'),
		    row = section.getIn(['inner', 0]),
		    rowLayout = row.getIn(['atts', 'layout']),
		    sectionPresetsList = this.props.sectionPresets,
		    rowPath = sectionPath.push(0);
		return React.createElement(
			'div',
			{ id: 'tatsu-section-preset-wrapper', style: { padding: '20px', height: '100%' } },
			React.createElement(
				'div',
				{ id: 'tatsu-preset-blank-section-wrapper' },
				'Blank Section'
			),
			React.createElement(
				'div',
				{ id: 'tatsu-preset-column-switch-wrapper' },
				React.createElement(ColumnSwitch, { targetLayout: rowLayout, path: rowPath })
			),
			React.createElement(PresetBlockWrapper, { presetsList: sectionPresetsList, sectionPath: sectionPath }),
			React.createElement(
				'div',
				{ className: 'tatsu-section-preset-load-more', onClick: this.toggleTemplatesModal },
				'View More Templates'
			),
			this.state.templatesModal && React.createElement(_templatesModal2.default, {
				visible: this.state.templatesModal,
				toggleTemplatesModal: this.toggleTemplatesModal,
				templates: this.props.templatesData,
				type: 'preset',
				path: sectionPath
			})
		);
	}

});
module.exports = SectionPreset;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 638 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

exports.default = function (props) {
    return React.createElement(
        "div",
        { className: "tatsu-info-box tatsu-info-box-" + props.type },
        props.children
    );
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 639 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _tooltip = __webpack_require__(58);

var _tooltip2 = _interopRequireDefault(_tooltip);

__webpack_require__(59);

var _templatesModal = __webpack_require__(358);

var _templatesModal2 = _interopRequireDefault(_templatesModal);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var store = __webpack_require__(11),
    undo = __webpack_require__(2).undo,
    redo = __webpack_require__(2).redo,
    saveData = __webpack_require__(2).saveData,
    changeTargetDisplay = __webpack_require__(2).changeTargetDisplay,
    isEqual = __webpack_require__(86),
    isEmpty = __webpack_require__(5),
    typewatch = __webpack_require__(122),
    Link = __webpack_require__(40).Link,
    openDrawer = __webpack_require__(2).openDrawer;
__webpack_require__(885);

var routeResolve = __webpack_require__(33);

var BottomToolBar = React.createClass({
	displayName: 'BottomToolBar',

saveHandler: function saveHandler(event) {

store.dispatch(saveData());
	},

getInitialState: function getInitialState() {

return {
			responsiveControls: false,
			responsiveTooltip: false,
			templatesModal: false,
			toolTipRenderData: {
				visible: false,
				top: '0',
				right: '0',
				helpText: ''
			}
		};
	},

undoHandler: function undoHandler(event) {

store.dispatch(undo());
	},

responsiveHandler: function responsiveHandler(target, event) {

store.dispatch(changeTargetDisplay(target));
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true,
		    messageType = nextProps.messageBox.get('type');
		result = !(Immutable.is(this.props.pageContent, nextProps.pageContent) && this.props.isDrawerOpen == nextProps.isDrawerOpen && this.props.targetDisplay === nextProps.targetDisplay && Immutable.is(this.props.messageBox, nextProps.messageBox) && isEqual(this.state, nextState) && Immutable.is(this.props.templateData, nextProps.templateData));
		return result;
	},

redoHandler: function redoHandler(event) {

store.dispatch(redo());
	},

requestClose: function requestClose(event) {

store.dispatch({ type: 'CLOSE_SNACKBAR' });
	},

componentDidUpdate: function componentDidUpdate() {

if (true === this.props.messageBox.get('open') && 'fatalError' != this.props.messageBox.get('type') && 'popUp	' != this.props.messageBox.get('type')) {
			typewatch(this.requestClose, 3000);
		}
	},

toolTipHandler: function toolTipHandler() {

this.setState({ showResponsiveTooltip: true });
	},

removeToolTip: function removeToolTip() {

this.setState({
			showResponsiveTooltip: false
		});
	},

getResponsiveControls: function getResponsiveControls(targetDisplay) {
		return React.createElement(
			'div',
			{ style: { bottom: this.state.responsiveControls ? '40px' : '-200px' }, className: 'tatsu-responsive-controls-panel' },
			React.createElement(
				_tooltip2.default,
				{ placement: 'left', title: 'Desktop' },
				React.createElement(
					'div',
					{ className: "be-pb-desktop " + ('desktop' === targetDisplay ? 'active' : ''), onClick: this.responsiveHandler.bind(null, 'desktop') },
					React.createElement(
						'svg',
						{ role: 'img', className: 'tatsu-svg-icon be-pb-desktop-icon', viewBox: '0 0 20 20' },
						React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-desktop' })
					)
				)
			),
			React.createElement(
				_tooltip2.default,
				{ placement: 'left', title: 'Laptop' },
				React.createElement(
					'div',
					{ className: "be-pb-laptop " + ('laptop' === targetDisplay ? 'active' : ''), onClick: this.responsiveHandler.bind(null, 'laptop') },
					React.createElement(
						'svg',
						{ role: 'img', className: 'tatsu-svg-icon be-pb-laptop-icon', viewBox: '0 0 20 20' },
						React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-laptop' })
					)
				)
			),
			React.createElement(
				_tooltip2.default,
				{ placement: 'left', title: 'Tablet' },
				React.createElement(
					'div',
					{ className: "be-pb-tablet " + ('tablet' === targetDisplay ? 'active' : ''), onClick: this.responsiveHandler.bind(null, 'tablet') },
					React.createElement(
						'svg',
						{ role: 'img', className: 'tatsu-svg-icon be-pb-tablet-icon', viewBox: '0 0 20 20' },
						React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-tablet' })
					)
				)
			),
			React.createElement(
				_tooltip2.default,
				{ placement: 'left', title: 'Mobile' },
				React.createElement(
					'div',
					{ className: "be-pb-mobile " + ('mobile' === targetDisplay ? 'active' : ''), onClick: this.responsiveHandler.bind(null, 'mobile') },
					React.createElement(
						'svg',
						{ role: 'img', className: 'tatsu-svg-icon be-pb-mobile-icon', viewBox: '0 0 20 20' },
						React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-mobile' })
					)
				)
			)
		);
	},

toggleResponsiveController: function toggleResponsiveController(event) {
		var currentState = this.state.responsiveControls;
		this.setState({
			responsiveControls: !currentState,
			showResponsiveTooltip: false
		});
	},

handleBtnClick: function handleBtnClick(type, event) {

var drawerMeta = Immutable.Map({
			action: type,
			saveType: 'save' == type ? 'templates' : ''
		});
		store.dispatch(openDrawer('template', drawerMeta));
	},

toggleTemplatesModal: function toggleTemplatesModal() {
		var templatesModal = this.state.templatesModal;

this.setState({
			templatesModal: !templatesModal
		});
	},

render: function render() {

var pageContent = this.props.pageContent,
		    targetDisplay = this.props.targetDisplay,
		    pastLength = pageContent.get('past').size,
		    futureLength = pageContent.get('future').size,
		    messageBox = this.props.messageBox,
		    loader,
		    parentRoute = routeResolve(this.props.routeProps.location.pathname),
		    messageType = messageBox.get('type'),
		    message = messageBox.get('message');
		var templatesModal = this.state.templatesModal;

if ('loader' === messageType) {
			message = React.createElement(
				'div',
				{ className: 'tatsu-loader-wrapper' },
				React.createElement('div', { className: 'tatsu-load-bar1' }),
				React.createElement('div', { className: 'tatsu-load-bar2' }),
				React.createElement('div', { className: 'tatsu-load-bar3' }),
				React.createElement('div', { className: 'tatsu-load-bar4' }),
				React.createElement('div', { className: 'tatsu-load-bar5' })
			);
		}

return React.createElement(
			'div',
			{ className: 'be-pb-bottom-toolbar-wrapper', style: { position: 'fixed', bottom: this.props.isDrawerOpen ? '-42px' : '0', width: '300px', zIndex: this.props.isDrawerOpen ? '1301' : '100' } },
			React.createElement(
				'div',
				{ className: 'tatsu-bottom-icons-wrapper' },
				React.createElement(
					'div',
					{ className: 'be-pb-save tatsu-bottom-tool', onClick: this.saveHandler },
					'Save'
				),
				React.createElement(
					_tooltip2.default,
					{ placement: 'top', title: 'Undo' },
					React.createElement(
						'div',
						{ className: "be-pb-undo tatsu-bottom-tool " + (0 < pastLength ? 'active' : ''), onClick: 0 < pastLength ? this.undoHandler : null },
						React.createElement(
							'svg',
							{ role: 'img', className: 'tatsu-svg-icon be-pb-undo-icon', viewBox: '0 0 20 20' },
							React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-undo' })
						)
					)
				),
				React.createElement(
					_tooltip2.default,
					{ placement: 'top', title: 'Redo' },
					React.createElement(
						'div',
						{ className: "be-pb-redo tatsu-bottom-tool " + (0 < futureLength ? 'active' : ''), onClick: 0 < futureLength ? this.redoHandler : null },
						React.createElement(
							'svg',
							{ role: 'img', className: 'tatsu-svg-icon be-pb-redo-icon', viewBox: '0 0 20 20' },
							React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-redo' })
						)
					)
				),
				React.createElement(
					_tooltip2.default,
					{ placement: 'top', visible: this.state.showResponsiveTooltip, title: 'Responsive Options' },
					React.createElement(
						'div',
						{ className: 'be-pb-responsive-contoller tatsu-bottom-tool', onClick: this.toggleResponsiveController, onMouseEnter: this.toolTipHandler, onMouseLeave: this.removeToolTip },
						React.createElement(
							'svg',
							{ role: 'img', className: 'tatsu-svg-icon be-pb-desktop-icon', viewBox: '0 0 20 20' },
							React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-' + targetDisplay })
						)
					)
				),
				React.createElement(
					_tooltip2.default,
					{ placement: 'top', title: 'Revisions' },
					React.createElement(
						Link,
						{ activeClassName: 'active', to: parentRoute + "tatsuRevisions/" },
						React.createElement(
							'div',
							{ className: 'be-pb-responsive-contoller tatsu-bottom-tool', onClick: this.revisionsBtnClick },
							React.createElement(
								'svg',
								{ role: 'img', className: 'tatsu-svg-icon be-pb-revisions-icon', viewBox: '0 0 20 20' },
								React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-revisions' })
							)
						)
					)
				),
				this.props.builderMode !== 'header_builder' && [React.createElement(
					_tooltip2.default,
					{ placement: 'top', title: 'Save Page as Template' },
					React.createElement(
						'div',
						{ onClick: this.handleBtnClick.bind(null, 'save'), className: 'be-pb-save-template-btn tatsu-bottom-tool' },
						React.createElement(
							'svg',
							{ role: 'img', className: 'be-pb-load-template-svg-icon tatsu-svg-icon', viewBox: '0 0 20 20' },
							React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-import' })
						)
					)
				), React.createElement(
					_tooltip2.default,
					{ placement: 'top', title: 'Load Page Template' },
					React.createElement(
						'div',
						{ onClick: this.toggleTemplatesModal, className: 'be-pb-load-template-btn tatsu-bottom-tool' },
						React.createElement(
							'svg',
							{ role: 'img', className: 'be-pb-save-template-svg-icon tatsu-svg-icon', viewBox: '0 0 20 20' },
							React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-export' })
						)
					)
				)]
			),
			React.createElement(
				'div',
				{ style: { bottom: true === messageBox.get('open') && 'popUp' != messageBox.get('type') ? '0' : null, width: 'description' != messageType ? '100%' : null }, className: "tatsu-snack-bar " + (!isEmpty(messageType) ? messageType : '') },
				'loader' === messageBox.get('type') ? message : React.createElement(
					'span',
					{ className: 'tatsu-post-man' },
					message
				)
			),
			[this.getResponsiveControls(targetDisplay), this.state.toolTipRenderData.visible ? this.getToolTip() : null, templatesModal && React.createElement(_templatesModal2.default, { visible: templatesModal, toggleTemplatesModal: this.toggleTemplatesModal, templates: this.props.templateData })]
		);
	}
});
exports.default = BottomToolBar;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 640 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var Immutable = __webpack_require__(3),
    listChecker = __webpack_require__(16).listChecker,
    browserHistory = __webpack_require__(40).browserHistory,
    encodePath = __webpack_require__(43).encodePath,
    setSelection = __webpack_require__(2).setSelection,
    routeResolve = __webpack_require__(33),
    store = __webpack_require__(11),
    getPathArray = __webpack_require__(39),
    isJSON = __webpack_require__(371),
    state = __webpack_require__(11);
var Breadcrumbs = React.createClass({
  displayName: 'Breadcrumbs',

propTypes: {
    path: listChecker
  },
  shouldArrowAdd: function shouldArrowAdd(index, size) {
    if (size - index === 1) {
      return '';
    } else {
      return ' >';
    }
  },

toLayoutManager: function toLayoutManager() {
    browserHistory.push(routeResolve(window.location.pathname) + 'layoutManager/');
  },

routeHandler: function routeHandler(path) {
    store.dispatch(setSelection(path, 'single'));
  },

getTargetElementFromPath: function getTargetElementFromPath(path) {

var currentPathArray = getPathArray(path, '', '');
    return this.props.pageContent.getIn(currentPathArray);
  },

render: function render() {

var tempRoute = "[" + this.props.pathFromRoute + "]",
        pathFromRoute = Immutable.List();

if (isJSON(tempRoute)) {
      pathFromRoute = Immutable.List(JSON.parse(tempRoute));
    }

var breadcrumbPath = pathFromRoute.size ? pathFromRoute : this.props.path,
        level,
        currentPath = Immutable.List(),
        breadcrumbLabel;

level = breadcrumbPath.size;
    return React.createElement(
      'div',
      { className: 'be-pb-breadcrumbs' },
      React.createElement(
        'p',
        { className: 'be-pb-breadcrumb-links' },
        this.props.builderMode === 'header_builder' && React.createElement(
          'span',
          { className: "be-pb-breadcrumb-link", onClick: this.toLayoutManager, style: { marginRight: '5px' } },
          React.createElement(
            'span',
            null,
            'Home '
          ),
          '>'
        ),
        breadcrumbPath.map(function (path, index) {
          currentPath = currentPath.push(path);
          var targetElement = this.getTargetElementFromPath(currentPath);
          if (null != targetElement) {
            breadcrumbLabel = targetElement.get('title') || state.getState().moduleOptions.getIn([targetElement.get('name'), 'title']) || 'Module';
            //breadcrumbLabel = ( (level - index) === 1 ) ? 'Here' : title;
            return React.createElement(
              'span',
              { key: index, className: level - index !== 1 ? "be-pb-breadcrumb-link" : '', onClick: breadcrumbLabel != 'Here' ? this.routeHandler.bind(null, currentPath) : '', style: { marginRight: '5px' } },
              ' ',
              React.createElement(
                'span',
                null,
                breadcrumbLabel
              ),
              ' ',
              this.shouldArrowAdd(index, level)
            );
          } else {
            return null;
          }
        }.bind(this))
      )
    );
  }
});
module.exports = Breadcrumbs;

// {
//   ( this.props.builderMode === 'header_builder' ) && <span className ="be-pb-breadcrumb-link" onClick = {this.routeHandler( 'Home' )} style = {{marginRight:'5px',cursor:'pointer'}}>{ 'Home' + ' \u2192' }</span>
// }
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 641 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _slider = __webpack_require__(625);

var _slider2 = _interopRequireDefault(_slider);

__webpack_require__(626);

var _index = __webpack_require__(150);

var _index2 = _interopRequireDefault(_index);

var _EditorHelpers = __webpack_require__(26);

__webpack_require__(886);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var BeSlider = function (_React$Component) {
    _inherits(BeSlider, _React$Component);

function BeSlider(props) {
        _classCallCheck(this, BeSlider);

var _this = _possibleConstructorReturn(this, (BeSlider.__proto__ || Object.getPrototypeOf(BeSlider)).call(this, props));

_this.options = null;
        _this.optionsType = null;
        _this.state = {
            value: 0,
            unit: ''
        };
        _this.processOptions = _this.processOptions.bind(_this);
        _this.handleChangeFromNumber = _this.handleChangeFromNumber.bind(_this);
        _this.handleChangeFromSlider = _this.handleChangeFromSlider.bind(_this);
        _this.validateValue = _this.validateValue.bind(_this);
        _this.getOptionVal = _this.getOptionVal.bind(_this);
        _this.getUnitFromValueOrOptions = _this.getUnitFromValueOrOptions.bind(_this);
        return _this;
    }

_createClass(BeSlider, [{
        key: 'componentWillMount',
        value: function componentWillMount() {
            this.processOptions(this.props.options);
            if (this.validateValue(this.props.value)) {
                var valueAndUnit = (0, _EditorHelpers.getValueAndUnit)(this.props.value);
                this.setState({
                    value: valueAndUnit.value,
                    unit: this.getUnitFromValueOrOptions(valueAndUnit)
                });
            } else {
                this.setState({
                    value: this.getOptionVal('min') || 0,
                    unit: this.getOptionVal('unit')
                });
            }
        }
    }, {
        key: 'getUnitFromValueOrOptions',
        value: function getUnitFromValueOrOptions(valueAndUnit) {
            return valueAndUnit.unit || (this.options ? this.getOptionVal('unit') || '' : '');
        }
    }, {
        key: 'processOptions',
        value: function processOptions(options) {
            if (this.validateOptions(options)) {
                this.options = options;
                if ((0, _EditorHelpers.isImmutable)(options)) {
                    this.optionsType = 'immutable';
                } else if ('[object Object]' == (0, _EditorHelpers.getObjectType)(options)) {
                    this.optionsType = 'object';
                }
            }
        }
    }, {
        key: 'validateOptions',
        value: function validateOptions(options) {
            if ((0, _EditorHelpers.isValidDataStructure)(options) && (0, _EditorHelpers.hasKeys)(options, ['min', 'max']) && (0, _EditorHelpers.validateValues)(options, true, true, true)) {
                return true;
            }
            return false;
        }
    }, {
        key: 'validateValue',
        value: function validateValue(value) {
            var floatValue = parseFloat(value),
                min = this.getOptionVal('min') || 0,
                max = this.getOptionVal('max') || 100;

return !isNaN(floatValue) ? this.options ? min <= floatValue && max >= floatValue : true : false;
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            if (this.props.value != nextProps.value) {

return finalValue;
        }
    }, {
        key: 'handleChangeFromSlider',
        value: function handleChangeFromSlider(value) {
            //comment this setState
            this.setState({
                value: value
            });
            value = this.shouldAddUnit(value, this.state.unit);
            if (!this.props.isAjax) {
                this.props.onChange(value);
            } else {
                (0, _EditorHelpers.debounce)(this.props.onChange, 700, value);
            }
        }
    }, {
        key: 'handleChangeFromNumber',
        value: function handleChangeFromNumber(value) {
            var valueAndUnit = (0, _EditorHelpers.getValueAndUnit)(value);
            //comment this setState
            this.setState({
                value: valueAndUnit.value,
                unit: valueAndUnit.unit
            });

value = this.shouldAddUnit(valueAndUnit.value, valueAndUnit.unit);

this.props.onChange(value);
        }
    }, {
        key: 'getOptionDefault',
        value: function getOptionDefault(option) {
            switch (option) {
                case 'min':
                    return 0;
                case 'max':
                    return 100;
                case 'step':
                    return 1;
                case 'value':
                    return 0;
                case 'unit':
                    return '';
                case 'showTooltip':
                    return true;
                default:
                    return null;
            }
        }
    }, {
        key: 'getOptionVal',
        value: function getOptionVal(option) {
            if ('object' == this.optionsType) {
                if (this.options.hasOwnProperty(option)) {
                    var val = this.options[option];
                    if ('unit' == option) {
                        if ('string' == typeof option) {
                            return val;
                        } else {
                            return val[0];
                        }
                    } else if ('showTooltip' == option && val) {
                        return true;
                    } else if (!isNaN(val)) {
                        return parseFloat(val);
                    } else {
                        return this.getOptionDefault(option);
                    }
                } else {
                    return ~['min', 'max', 'step', 'showTooltip'].indexOf(option) ? this.getOptionDefault(option) : null;
                }
            } else if ('immutable' == this.optionsType) {
                if (this.options.has(option)) {
                    var _val = this.options.get(option);
                    if ('unit' == option) {
                        if (Immutable.List.isList(_val)) {
                            return _val.get(0);
                        } else {
                            return _val;
                        }
                    } else if ('showTooltip' == option && _val) {
                        return true;
                    } else if (!isNaN(_val)) {
                        return parseFloat(_val);
                    } else {
                        return this.getOptionDefault(option);
                    }
                } else {
                    return ~['min', 'max', 'step', 'showTooltip'].indexOf(option) ? this.getOptionDefault(option) : null;
                }
            }
            return null;
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

return BeSlider;
}(React.Component);

exports.default = BeSlider;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 642 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _checkbox = __webpack_require__(204);

var _checkbox2 = _interopRequireDefault(_checkbox);

var _menu = __webpack_require__(91);

var _menu2 = _interopRequireDefault(_menu);

__webpack_require__(205);

__webpack_require__(92);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _index = __webpack_require__(213);

var _index2 = _interopRequireDefault(_index);

__webpack_require__(887);

var _popoverMenu = __webpack_require__(154);

var _popoverMenu2 = _interopRequireDefault(_popoverMenu);

var _EditorConstants = __webpack_require__(95);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var GradientColor = __webpack_require__(212);
var Item = _menu2.default.Item;

var BoxShadow = function (_React$Component) {
    _inherits(BoxShadow, _React$Component);

function BoxShadow(props) {
        _classCallCheck(this, BoxShadow);

var _this = _possibleConstructorReturn(this, (BoxShadow.__proto__ || Object.getPrototypeOf(BoxShadow)).call(this, props));

var parsedValue = '';
        if (props.value) {
            parsedValue = _this.parseValues(props.value);
        } else {
            parsedValue = { numberValue: '', colorValue: '' };
        }

_this.state = {
            numberValue: parsedValue.numberValue,
            colorValue: parsedValue.colorValue,
            insetValue: parsedValue.insetValue
        };
        return _this;
    }

_createClass(BoxShadow, [{
        key: 'parseValues',
        value: function parseValues(value) {
            var valueArray = value.split(' '),
                numberValue,
                colorValue,
                insetValue;

if (valueArray[0] === 'inset') {
                insetValue = 'inset';
                numberValue = valueArray.slice(1, 5);
                colorValue = valueArray[5];
            } else {
                insetValue = '';
                numberValue = valueArray.slice(0, 4);
                colorValue = valueArray[4];
            }

numberValue = numberValue.join(" ");
            return {
                numberValue: numberValue,
                colorValue: colorValue,
                insetValue: insetValue
            };
        }
    }, {
        key: 'handlePresetSelect',
        value: function handlePresetSelect(preset) {
            this.props.onChange(_EditorConstants.boxShadowPresets[preset.key]);
        }
    }, {
        key: 'changeHandler',
        value: function changeHandler(componentType, value) {
            var tempValue = '';
            if ('number' === componentType) {
                var insetValue = '';
                if (this.state.insetValue === 'inset') {
                    insetValue = 'inset ';
                }

tempValue = insetValue + value + " " + this.state.colorValue;
                this.setState({ numberValue: value });
            } else if ('color' === componentType) {

var insetValue = '';
                if (this.state.insetValue === 'inset') {
                    insetValue = 'inset ';
                }

value = value.get('solid').color;
                tempValue = insetValue + this.state.numberValue + ' ' + value;
                this.setState({ colorValue: value });
            } else if (componentType === 'inset') {
                if (value.target.checked) {
                    value = 'inset ';
                } else {
                    value = '';
                }
                this.setState({ insetValue: value });
                tempValue = value + this.state.numberValue + ' ' + this.state.colorValue;
            }

this.props.onChange(tempValue);
        }
    }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            var value = nextProps.value,
                parsedValue = this.parseValues(value);

this.setState({
                numberValue: parsedValue.numberValue,
                colorValue: parsedValue.colorValue,
                insetValue: parsedValue.insetValue
            });
        }
    }, {
        key: 'render',
        value: function render() {
            var labels = ['X', 'Y', 'Blur', 'Spread'],
                numberValue = this.state.numberValue,
                colorValue = this.state.colorValue,
                numberComponentOptions = {
                labels: labels,
                unit: ['px']
            },
                presetArray = Object.keys(_EditorConstants.boxShadowPresets),
                menuItems = [];

menuItems = presetArray.map(function (preset) {
                return _react2.default.createElement(
                    Item,
                    { key: preset },
                    ' ',
                    preset,
                    ' '
                );
            });

return _react2.default.createElement(
                'div',
                { className: 'be-box-shadow-wrap be-ui-component' },
                _react2.default.createElement(_index2.default, { options: numberComponentOptions, value: numberValue, onChange: this.changeHandler.bind(this, 'number') }),
                _react2.default.createElement(
                    'div',
                    { className: 'be-box-shadow-color-wrap' },
                    _react2.default.createElement(
                        'span',
                        { className: 'be-label' },
                        ' Color '
                    ),
                    _react2.default.createElement(GradientColor, {
                        enableGradient: false,
                        value: colorValue,
                        onChange: this.changeHandler.bind(this, 'color'),
                        quickChange: true,
                        hideClearBtn: true
                    }),
                    _react2.default.createElement(
                        'div',
                        { className: 'be-box-shadow-inset ' },
                        'Inset',
                        _react2.default.createElement(_checkbox2.default, { checked: this.state.insetValue === 'inset', onChange: this.changeHandler.bind(this, 'inset') })
                    )
                ),
                _react2.default.createElement(
                    _popoverMenu2.default,
                    { className: 'be-box-shadow-preset-menu', icon: 'ellipsis', width: 'auto', wrapWithinViewport: true, positionAdjustment: { top: 25, left: -30 } },
                    _react2.default.createElement(
                        _menu2.default,
                        { mode: 'vertical', style: { width: '100%', borderRight: '0' }, selectable: false, onClick: this.handlePresetSelect.bind(this), className: 'be-ui-component be-menu' },
                        menuItems
                    )
                )
            );
        }
    }]);

return BoxShadow;
}(_react2.default.Component);

exports.default = BoxShadow;

/***/ }),
/* 643 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _index = __webpack_require__(213);

var _index2 = _interopRequireDefault(_index);

__webpack_require__(889);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var GradientColor = __webpack_require__(212);

var BoxShadow = function (_React$Component) {
    _inherits(BoxShadow, _React$Component);

function BoxShadow(props) {
        _classCallCheck(this, BoxShadow);

var _this = _possibleConstructorReturn(this, (BoxShadow.__proto__ || Object.getPrototypeOf(BoxShadow)).call(this, props));

var parsedValue = '';
        if (props.value) {
            parsedValue = _this.parseValues(props.value);
        } else {
            parsedValue = { numberValue: '', colorValue: '' };
        }

_this.state = {
            numberValue: parsedValue.numberValue,
            colorValue: parsedValue.colorValue
        };
        return _this;
    }

_createClass(BoxShadow, [{
        key: 'getParamsFromValue',
        value: function getParamsFromValue(value) {
            var withoutLastBracket = value.slice(0, -1);
            return withoutLastBracket.replace('drop-shadow(', '');
        }
    }, {
        key: 'parseValues',
        value: function parseValues(value) {
            value = this.getParamsFromValue(value);
            var valueArray = value.split(' '),
                numberValue,
                colorValue;

numberValue = valueArray.slice(0, 3);
            colorValue = valueArray[3];

numberValue = numberValue.join(" ");
            return {
                numberValue: numberValue,
                colorValue: colorValue
            };
        }
    }, {
        key: 'changeHandler',
        value: function changeHandler(componentType, value) {
            var tempValue = '';
            if ('number' === componentType) {
                tempValue = value + " " + this.state.colorValue;
                this.setState({ numberValue: value });
            } else if ('color' === componentType) {
                value = value.get('solid').color;
                tempValue = this.state.numberValue + ' ' + value;
                this.setState({ colorValue: value });
            }

tempValue = 'drop-shadow(' + tempValue + ')';

this.setState({
                numberValue: parsedValue.numberValue,
                colorValue: parsedValue.colorValue
            });
        }
    }, {
        key: 'render',
        value: function render() {
            var labels = ['X', 'Y', 'Blur'],
                numberValue = this.state.numberValue,
                colorValue = this.state.colorValue,
                numberComponentOptions = {
                labels: labels,
                unit: ['px']
            };

return _react2.default.createElement(
                'div',
                { className: 'be-box-shadow-wrap be-drop-shadow be-ui-component' },
                _react2.default.createElement(_index2.default, { options: numberComponentOptions, value: numberValue, onChange: this.changeHandler.bind(this, 'number') }),
                _react2.default.createElement(
                    'div',
                    { className: 'be-box-shadow-color-wrap' },
                    _react2.default.createElement(
                        'span',
                        { className: 'be-label' },
                        ' Color '
                    ),
                    _react2.default.createElement(GradientColor, {
                        enableGradient: false,
                        value: colorValue,
                        onChange: this.changeHandler.bind(this, 'color'),
                        quickChange: true,
                        hideClearBtn: true
                    })
                )
            );
        }
    }]);

return BoxShadow;
}(_react2.default.Component);

exports.default = BoxShadow;

/***/ }),
/* 644 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var React = __webpack_require__(0),
    ReactDOM = __webpack_require__(7),
    Swatches = __webpack_require__(355),
    Palettes = __webpack_require__(354),
    SketchPicker = __webpack_require__(1214).SketchPicker;

__webpack_require__(890);

var GradientColorPicker = React.createClass({
    displayName: 'GradientColorPicker',

getDefaultValues: function getDefaultValues() {
        return {
            newColor: "rgba(0,0,0,1)",
            defaultSolidColor: "rgba(255,255,255,1)",
            defaultGradientBar: [{ barIndex: 0, color: 'rgba(255,255,255,1)', position: 0, isClicked: false }, { barIndex: 1, color: 'rgba(0,0,0,1)', position: 170, isClicked: false }],
            defaultGradientAngle: '45'
        };
    },

getInitialState: function getInitialState() {
        // Variables to populate State
        var activeState = '',
            gradientBarArray = [],
            solidColor = this.getDefaultValues().defaultSolidColor,
            gradientBar = this.getDefaultValues().defaultGradientBar,
            gradientAngle = this.getDefaultValues().defaultGradientAngle,
            currentGradientColor = '',
            currentGradientKey = 1,
            maxBarKey = 0,
            isSolidVisible = true,
            isGradientVisible = false,
            isSwatchVisible = false,
            selectedSwatch = '',
            selectedSwatchType = '',
            searchSwatch = '',
            isPaletteVisible = false,
            selectedPalette = '',
            selectedPaletteType = '';

// Form Gradient Array from Props
        if (this.props.color.hasOwnProperty('gradient')) {
            gradientBarArray = this.createGradientArray(this.props.color.gradient.color.colorPositions);
            gradientBar = gradientBarArray;
            gradientAngle = this.props.color.gradient.color.angle;
            currentGradientColor = gradientBarArray[0].color;
            currentGradientKey = 1;
            maxBarKey = gradientBarArray.length;
        }

// Get Solid Color from Props
        if (this.props.color.hasOwnProperty('solid') && this.validateColor(this.props.color.solid.color)) {
            solidColor = this.props.color.solid.color;
        }

// Get Active Panel from Props 
        activeState = this.props.color.active != '' ? this.props.color.active : 'solid';

// Get Swatch/Palette Information from Props
        if (this.props.color.hasOwnProperty('id') && this.props.colorHub !== '') {
            var id = this.props.color.id,
                colorType = id.startsWith('swatch') ? 'swatch' : '';
            colorType = id.startsWith('palette') ? 'palette' : colorType;
            var colorKey = id.split(':')[1];
            if (this.isColorKeyValid(colorType, colorKey)) {
                if (colorType === 'swatch') {
                    selectedSwatch = colorKey, isSwatchVisible = true, isSolidVisible = false;
                } else {
                    selectedPalette = parseInt(colorKey), isPaletteVisible = true, isSolidVisible = false;
                }
            }
        } else {
            // Enable panel only if a Swatch or Palette is not selected
            if (activeState == 'gradient') {
                isGradientVisible = true;
                isSolidVisible = false;
            } else {
                isSolidVisible = true;
                isGradientVisible = false;
            }
        }
        // Store State - OPTIONAL
        this.InitalState = this.state;

// Set Initial State
        return {
            color: solidColor,
            currentGradientColor: currentGradientColor,
            currentGradientKey: currentGradientKey,
            maxBarKey: gradientBar.length,
            isVisible: true,
            isSolidVisible: isSolidVisible,
            isGradientVisible: isGradientVisible,
            gradientAngle: gradientAngle,
            gradientBar: gradientBar,
            isSwatchVisible: isSwatchVisible,
            selectedSwatch: selectedSwatch,
            selectedSwatchType: selectedSwatchType,
            searchSwatch: searchSwatch,
            isPaletteVisible: isPaletteVisible,
            selectedPalette: selectedPalette,
            selectedPaletteType: selectedPaletteType
        };
    },

componentDidMount: function componentDidMount() {

//Calculate top based on panel selected
        var panel = this.state.isSolidVisible ? 'solid' : this.state.isGradientVisible ? 'gradient' : this.state.isSwatchVisible ? 'swatch' : 'palette';
        this.props.calculateTop(panel);
    },

/** HELPER FUNCTIONS **/
    // Validate Color
    validateColor: function validateColor(color) {

// Sort Gradient Color Stops based on position
    gradientSort: function gradientSort(gradientBarArray) {
        var sortedArray = gradientBarArray.sort(function (a, b) {
            {
                return a.position - b.position;
            }
        });
        return sortedArray;
    },
    // Compute Gradient Value from State Array
    computeGradient: function computeGradient(theState, includeAngle, angle) {
        var computedGradient = '';
        if (theState.gradientBar.length >= 2) {
            computedGradient = 'linear-gradient(';
            computedGradient = computedGradient + (includeAngle ? angle : '90') + 'deg ';

this.gradientSort(theState.gradientBar).map(function (item, index) {
                computedGradient = computedGradient + ',' + item.color + ' ' + Math.floor(item.position / 170 * 100) + '%';
            });
            computedGradient = computedGradient + ')';
        } else if (theState.gradientBar.length === 1) {
            computedGradient = theState.gradientBar[0].color;
        } else {
            computedGradient = theState.color;
        }
        return computedGradient;
    },

convertComponent: function convertComponent(colorValue) {
        var hex = colorValue.toString(16);
        return hex.length == 1 ? "0" + hex : hex;
    },

/** ACTIONS **/
    // Enable Solid Picker 
    showSolidPicker: function showSolidPicker() {
        this.setState({
            isSolidVisible: true,
            isGradientVisible: false,
            isSwatchVisible: false,
            isPaletteVisible: false
        }, this.props.calculateTop.bind(null, 'solid'));
        this.props.onChange(this.colorPickerData('panelChange', 'solid'));
    },
    // Enable Gradient Picker
    showGradientPicker: function showGradientPicker() {
        this.setState({
            isSolidVisible: false,
            isGradientVisible: true,
            isSwatchVisible: false,
            isPaletteVisible: false
        }, this.props.calculateTop.bind(null, 'gradient'));
        this.props.onChange(this.colorPickerData('panelChange', 'gradient'));
    },
    // Enable Swatches
    showSwatches: function showSwatches() {
        this.setState({
            isSolidVisible: false,
            isGradientVisible: false,
            isSwatchVisible: true,
            isPaletteVisible: false
        }, this.props.calculateTop.bind(null, 'swatch'));
        this.props.onChange(this.colorPickerData('panelChange', 'swatch'));
    },
    // Enable Palette
    showPalette: function showPalette() {
        this.setState({
            isSolidVisible: false,
            isGradientVisible: false,
            isSwatchVisible: false,
            isPaletteVisible: true
        }, this.props.calculateTop.bind(null, 'palette'));
        this.props.onChange(this.colorPickerData('panelChange', 'palette'));
    },
    // Color Change
    changeColor: function changeColor(type, index, choosenColor) {
        var rgbaColor = 'rgba(' + choosenColor.rgb.r + ',' + choosenColor.rgb.g + ',' + choosenColor.rgb.b + ',' + choosenColor.rgb.a + ')';
        if (type === 'solid') {
            this.setState({
                color: rgbaColor,
                selectedSwatch: '',
                selectedSwatchType: '',
                selectedPalette: '',
                selectedPaletteType: ''
            });
            this.props.onChange(this.colorPickerData('solidColorChange', rgbaColor));
        } else if (type === 'gradient') {
            var stateGradientBar = this.state.gradientBar;
            for (var i in stateGradientBar) {
                if (stateGradientBar[i].barIndex === index) {
                    stateGradientBar[i].color = rgbaColor;
                }
            }
            this.setState({
                gradientBar: stateGradientBar,
                currentGradientColor: rgbaColor,
                selectedSwatch: '',
                selectedSwatchType: '',
                selectedPalette: '',
                selectedPaletteType: ''
            });
            this.props.onChange(this.colorPickerData('gradientColorChange', stateGradientBar));
        }
    },
    // Current Color Chosen on the Gradient Bar
    setGradientColor: function setGradientColor(currentColor, index) {
        this.setState({
            currentGradientColor: currentColor,
            currentGradientKey: index
        });
    },
    // To change Angle
    changeAngle: function changeAngle(event) {
        this.setState({
            gradientAngle: event.target.value,
            selectedSwatch: '',
            selectedSwatchType: '',
            selectedPalette: '',
            selectedPaletteType: ''
        });
        this.props.onChange(this.colorPickerData('angleChange', event.target.value));
    },
    // Add new color Stop
    addnewPicker: function addnewPicker(event) {
        var rect = ReactDOM.findDOMNode(this.refs['gradientbar']).getBoundingClientRect(),
            newPickerIndex = this.state.maxBarKey + 1,
            newPickerPosition = Math.floor(event.pageX - rect.left),
            newGradientBar = this.state.gradientBar,
            newPicker = {
            barIndex: newPickerIndex,
            position: newPickerPosition,
            color: this.getDefaultValues().newColor,
            isClicked: false
        };
        newGradientBar.push(newPicker);
        this.setState({
            maxBarKey: newPickerIndex,
            gradientBar: newGradientBar,
            currentGradientKey: newPickerIndex,
            currentGradientColor: this.getDefaultValues().newColor,
            selectedSwatch: '',
            selectedSwatchType: '',
            selectedPalette: '',
            selectedPaletteType: ''
        });
        this.props.onChange(this.colorPickerData('gradientColorChange', newGradientBar));
    },
    // Toggle picker selection on Mouse up / down
    handlePicker: function handlePicker(clickStatus, currentIndex, event) {
        var newGradientBar = this.state.gradientBar,
            currentBarIndex = this.state.currentGradientKey;
        if (clickStatus === true) {
            currentBarIndex = currentIndex;
        }

for (var i in newGradientBar) {
            if (newGradientBar[i].barIndex === currentBarIndex && newGradientBar[i].isClicked !== clickStatus) {
                newGradientBar[i].isClicked = clickStatus;
                this.setState({
                    gradientBar: newGradientBar,
                    currentGradientKey: currentBarIndex,
                    selectedSwatch: '',
                    selectedSwatchType: '',
                    selectedPalette: '',
                    selectedPaletteType: ''
                });
                this.props.onChange(this.colorPickerData('gradientColorChange', newGradientBar));
            }
        }
    },
    // To change Color Stop Position
    movePicker: function movePicker(event) {
        event.preventDefault();
        var newGradientBar = this.state.gradientBar,
            currentBarIndex = this.state.currentGradientKey,
            rect = ReactDOM.findDOMNode(this.refs['gradientbar']).getBoundingClientRect(),
            pickerPosition = Math.floor(event.screenX - rect.left);
        for (var i in newGradientBar) {
            if (newGradientBar[i].barIndex === currentBarIndex) {
                if (newGradientBar[i].isClicked === true) {
                    if (pickerPosition >= 0 && pickerPosition <= 166) {
                        newGradientBar[i].position = pickerPosition;
                    } else if (pickerPosition < 0) {
                        newGradientBar[i].position = 0;
                    } else {
                        newGradientBar[i].position = 170;
                    }
                    this.setState({
                        gradientBar: newGradientBar,
                        selectedSwatch: '',
                        selectedSwatchType: '',
                        selectedPalette: '',
                        selectedPaletteType: ''
                    });
                    this.props.onChange(this.colorPickerData('gradientColorChange', newGradientBar));
                }
            }
        }
    },
    // To Remove Color Stop
    removePicker: function removePicker(key) {
        if (this.state.gradientBar.length > 1) {
            var newGradientBar = this.state.gradientBar;
            newGradientBar.splice(key, 1);
            this.setState({
                gradientBar: newGradientBar,
                currentGradientKey: 1,
                selectedSwatch: '',
                selectedSwatchType: '',
                selectedPalette: '',
                selectedPaletteType: ''
            });
        }
        this.props.onChange(this.colorPickerData('gradientColorChange', newGradientBar));
    },
    // On Swatch Click
    swatchClick: function swatchClick(selectedSwatch) {
        var swatchColor = selectedSwatch.color;
        if (this.state.selectedSwatch === selectedSwatch.key) {
            this.setState({
                selectedSwatch: '',
                selectedSwatchType: ''
            });
            this.props.onChange(this.colorPickerData('', ''));
        } else {
            if ((typeof swatchColor === 'undefined' ? 'undefined' : _typeof(swatchColor)) === 'object') {
                // Form Gradient Array from Swatch Data
                var gradientBarArray = this.createGradientArray(swatchColor.colorPositions);

this.setState({
                    gradientBar: gradientBarArray,
                    gradientAngle: swatchColor.angle,
                    currentGradientKey: 1,
                    currentGradientColor: gradientBarArray[0].color,
                    maxBarKey: gradientBarArray.length,
                    selectedSwatch: selectedSwatch.key,
                    selectedSwatchType: 'gradient',
                    selectedPalette: '',
                    selectedPaletteType: ''
                });

this.props.onChange(this.colorPickerData('swatchChangeGradient', selectedSwatch));
            } else {
                // Update Solid Color from Swatch Data
                this.setState({
                    color: swatchColor,
                    selectedSwatch: selectedSwatch.key,
                    selectedSwatchType: 'solid',
                    selectedPalette: '',
                    selectedPaletteType: ''
                });
                this.props.onChange(this.colorPickerData('swatchChangeSolid', selectedSwatch));
            }
        }
    },
    // On Palette Click
    paletteClick: function paletteClick(paletteID, paletteColor) {
        if (this.state.selectedPalette === paletteID) {
            this.setState({
                selectedPalette: '',
                selectedPaletteType: ''
            });
            this.props.onChange(this.colorPickerData('', ''));
        } else {
            if ((typeof paletteColor === 'undefined' ? 'undefined' : _typeof(paletteColor)) === 'object') {
                // Form Gradient Array from Palette Data
                var gradientBarArray = this.createGradientArray(paletteColor.colorPositions);

this.setState({
                    gradientBar: gradientBarArray,
                    gradientAngle: paletteColor.angle,
                    currentGradientKey: 1,
                    currentGradientColor: gradientBarArray[0].color,
                    maxBarKey: gradientBarArray.length,
                    selectedPalette: paletteID,
                    selectedPaletteType: 'gradient',
                    selectedSwatch: '',
                    selectedSwatchType: ''
                });
                this.props.onChange(this.colorPickerData('paletteChangeGradient', { key: paletteID, color: paletteColor }));
            } else {
                // Update Solid Color from Palette Data
                this.setState({
                    color: paletteColor,
                    selectedPalette: paletteID,
                    selectedPaletteType: 'solid',
                    selectedSwatch: '',
                    selectedSwatchType: ''
                });
                this.props.onChange(this.colorPickerData('paletteChangeSolid', { key: paletteID, color: paletteColor }));
            }
        }
    },

/** DATA SENT TO PARENT COMPONENTS **/
    colorPickerData: function colorPickerData(changeType, changeInfo) {

var colorPicker = {};

// Set Default Values from State
        var gradientBarArray = this.state.gradientBar,
            angle = this.state.gradientAngle;

if (this.state.isGradientVisible || this.state.selectedSwatchType === 'gradient') {
            colorPicker.active = 'gradient';
        } else {
            colorPicker.active = 'solid';
        }

colorPicker.solid = { color: this.state.color };
        // Modify Data based on Change Info
        switch (changeType) {
            case 'panelChange':
                colorPicker.active = changeInfo;
                if (changeInfo === 'swatch' || changeInfo === 'palette') {
                    if (this.state.selectedSwatchType === 'gradient') {
                        colorPicker.active = 'gradient';
                    } else {
                        colorPicker.active = 'solid';
                    }
                }
                if (this.state.selectedSwatch !== '') {
                    colorPicker.id = 'swatch:' + this.state.selectedSwatch;
                }
                break;
            case 'solidColorChange':
                colorPicker.solid.color = changeInfo;
                break;
            case 'gradientColorChange':
                gradientBarArray = changeInfo;
                break;
            case 'swatchChangeSolid':
                colorPicker.active = 'solid';
                colorPicker.solid = { color: changeInfo.color };
                colorPicker.id = 'swatch:' + changeInfo.key;
                break;
            case 'swatchChangeGradient':
                colorPicker.active = 'gradient';
                colorPicker.gradient = { color: changeInfo.color };
                colorPicker.id = 'swatch:' + changeInfo.key;
                break;
            case 'paletteChangeSolid':
                colorPicker.active = 'solid';
                colorPicker.solid = { color: changeInfo.color };
                colorPicker.id = 'palette:' + changeInfo.key;
                break;
            case 'paletteChangeGradient':
                colorPicker.active = 'gradient';
                colorPicker.gradient = { color: changeInfo.color };
                colorPicker.id = 'palette:' + changeInfo.key;
                break;
            case 'angleChange':
                angle = changeInfo;
                break;
        }
        if (changeType !== 'swatchChangeGradient' && changeType !== 'paletteChangeGradient') {
            // changeType !== 'swatchChangeSolid' && changeType !== 'paletteChangeSolid' 
            colorPicker.gradient = { color: { angle: angle } };
            colorPicker.gradient.color.colorPositions = {};
            if (gradientBarArray.length >= 2) {
                this.gradientSort(gradientBarArray).map(function (item, index) {
                    colorPicker.gradient.color.colorPositions[Math.floor(item.position / 170 * 100)] = item.color;
                });
            } else if (gradientBarArray.length === 1) {
                colorPicker.gradient.color.colorPositions[0] = gradientBarArray[0].color;
            }
        }
        return colorPicker;
    },

// Markup to print Color Picker Tab 
    colorPickerTab: function colorPickerTab() {
        return React.createElement(
            'div',
            { className: 'be-color-picker-tab' },
            (this.props.enableGradient || this.props.enableSwatch || this.props.enablePalette) && React.createElement(
                'span',
                { onClick: this.showSolidPicker.bind(this), className: this.state.isSolidVisible ? "visible-palette" : "" },
                'Solid'
            ),
            this.props.enableGradient && React.createElement(
                'span',
                { onClick: this.showGradientPicker.bind(this), className: this.state.isGradientVisible ? "visible-palette" : "" },
                'Gradient'
            ),
            this.props.enableSwatch && React.createElement(
                'span',
                { onClick: this.showSwatches.bind(this), className: this.state.isSwatchVisible ? "visible-palette" : "" },
                'Swatch'
            ),
            this.props.enablePalette && React.createElement(
                'span',
                { onClick: this.showPalette.bind(this), className: this.state.isPaletteVisible ? "visible-palette" : "" },
                'Palette'
            )
        );
    },
    // Markup to print Color Picker Paletter
    colorPalette: function colorPalette() {
        var gradientBarStyle = {
            background: this.computeGradient(this.state, false)
        };
        if (this.state.isSolidVisible) {
            return React.createElement(
                'div',
                { className: 'be-color-palette' },
                React.createElement(SketchPicker, { color: this.state.color, onChange: this.props.quickChange ? this.changeColor.bind(this, 'solid', 0) : '', onChangeComplete: this.changeColor.bind(this, 'solid', 0) })
            );
        } else if (this.state.isGradientVisible) {
            return React.createElement(
                'div',
                { className: 'be-color-palette' },
                React.createElement(
                    'div',
                    { className: 'gradient-wrap' },
                    React.createElement(
                        'div',
                        { className: 'gradient-settings' },
                        React.createElement('input', { type: 'number', label: 'Degree', className: 'be-color-picker-gradient-angle', value: this.state.gradientAngle, onChange: this.changeAngle.bind(this) }),
                        React.createElement(
                            'p',
                            null,
                            'Angle'
                        )
                    ),
                    React.createElement(
                        'div',
                        { onMouseUp: this.handlePicker.bind(this, false, 0),
                            onMouseMove: this.movePicker.bind(this),
                            className: 'gradient-bar-wrapper' },
                        React.createElement('div', { className: 'gradient-bar', ref: 'gradientbar', onClick: this.addnewPicker.bind(this), style: gradientBarStyle }),
                        React.createElement(
                            'div',
                            null,
                            React.createElement(
                                'ul',
                                { className: 'gradient-picker' },
                                this.gradientSort(this.state.gradientBar).map(function (item, index) {
                                    var pickerStyle = {
                                        marginLeft: item.position - 6 + 'px',
                                        background: item.color
                                    };
                                    return React.createElement('li', { draggable: 'false',
                                        key: index,
                                        onDoubleClick: this.removePicker.bind(this, index),
                                        onMouseDown: this.handlePicker.bind(this, true, item.barIndex),
                                        onMouseUp: this.handlePicker.bind(this, false, 0),
                                        onClick: this.setGradientColor.bind(this, item.color, item.barIndex),
                                        style: pickerStyle });
                                }, this)
                            )
                        )
                    )
                ),
                React.createElement(SketchPicker, { onChange: this.props.quickChange ? this.changeColor.bind(this, 'gradient', this.state.currentGradientKey) : '', onChangeComplete: this.changeColor.bind(this, 'gradient', this.state.currentGradientKey), color: this.state.currentGradientColor })
            );
        } else if (this.state.isSwatchVisible) {
            return React.createElement(Swatches, {
                swatchClick: this.swatchClick,
                enableGradient: this.props.enableGradient,
                colorHub: this.props.colorHub,
                selectedSwatch: this.state.selectedSwatch
            });
        } else if (this.state.isPaletteVisible) {
            return React.createElement(Palettes, {
                paletteClick: this.paletteClick,
                enableGradient: this.props.enableGradient,
                colorHub: this.props.colorHub,
                selectedPalette: this.state.selectedPalette
            });
        }
    },

// Main Render Method
    render: function render() {
        return React.createElement(
            'div',
            null,
            React.createElement(
                'div',
                { className: 'be-gradient-color-panel' },
                this.colorPickerTab(),
                this.colorPalette()
            )
        );
    }
});

module.exports = GradientColorPicker;

/***/ }),
/* 645 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _checkbox = __webpack_require__(204);

var _checkbox2 = _interopRequireDefault(_checkbox);

__webpack_require__(205);

__webpack_require__(898);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var React = __webpack_require__(0),
    Immutable = __webpack_require__(3);

var GroupedCheckBoxComponent = React.createClass({
	displayName: 'GroupedCheckBoxComponent',

validateOptions: function validateOptions(options) {
		var result = true;
		if (!Immutable.Map.isMap(options)) {
			result = false;
		}
		return result;
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
		result = !(this.props.value === nextProps.value);
		return result;
	},

_handleCheck: function _handleCheck(option, event) {
		var currentCheckedValues = this.props.value,
		    dataString = '',
		    isInputChecked = false,
		    currentCheckedArray = 'string' == typeof currentCheckedValues ? currentCheckedValues.split(',') : [];
		currentCheckedArray = 1 == currentCheckedArray.length && '' == currentCheckedArray[0] ? [] : currentCheckedArray;

if (currentCheckedArray.indexOf(option) === -1) {
			isInputChecked = true;
		}

if (isInputChecked) {
			currentCheckedArray.push(option);
		} else {
			var currentOptionIndex = currentCheckedArray.indexOf(option);
			currentCheckedArray.splice(currentOptionIndex, 1);
		}
		dataString = currentCheckedArray.join(',');
		this.props.onChange(dataString, 1);
	},

isChecked: function isChecked(key) {

var currentCheckedValues = this.props.value,
		    currentCheckedArray = 'string' == typeof currentCheckedValues ? currentCheckedValues.split(',') : [];
		if (1 == currentCheckedArray.length && '' == currentCheckedArray[0]) {
			return false;
		} else {
			return -1 < currentCheckedArray.indexOf(key);
		}
	},

render: function render() {

return this.validateOptions(this.props.options) ? React.createElement(
			'div',
			{ className: this.props.className },
			this.props.options.map(function (label, key) {
				return React.createElement(
					_checkbox2.default,
					{
						style: { fontSize: '14px', display: 'block', margin: 0 },
						onChange: this._handleCheck.bind(null, key),
						checked: this.isChecked(key)
					},
					label
				);
			}.bind(this))
		) : null;
	}

});
exports.default = GroupedCheckBoxComponent;

/***/ }),
/* 646 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _input = __webpack_require__(77);

var _input2 = _interopRequireDefault(_input);

__webpack_require__(78);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _Grid = __webpack_require__(1350);

var _Grid2 = _interopRequireDefault(_Grid);

var _index = __webpack_require__(93);

var _index2 = _interopRequireDefault(_index);

__webpack_require__(891);

var _EditorHelpers = __webpack_require__(26);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Search = _input2.default.Search;

var RenderToBody = __webpack_require__(125),
    findDOMNode = ReactDOM.findDOMNode;

var IconPicker = function (_React$Component) {
    _inherits(IconPicker, _React$Component);

function IconPicker(props) {
        _classCallCheck(this, IconPicker);

var _this = _possibleConstructorReturn(this, (IconPicker.__proto__ || Object.getPrototypeOf(IconPicker)).call(this, props));

var currentSelected = '',
            initialIconKit = void 0;
        if (_this.validateValue(props.value)) {
            currentSelected = props.value;
        }
        initialIconKit = _this.getCurrentIconKit(currentSelected);
        _this.state = {
            displayIconList: false,
            iconKit: initialIconKit,
            selected: currentSelected,
            filter: ''
        };
        _this.clickHandler = _this.clickHandler.bind(_this);
        _this.changeHandler = _this.changeHandler.bind(_this);
        _this.closeHandler = _this.clickHandler.bind(_this);
        _this.changeIconKit = _this.changeIconKit.bind(_this);
        return _this;
    }

_createClass(IconPicker, [{
        key: 'parseSelectedIcon',
        value: function parseSelectedIcon(icon) {
            return 'string' == typeof icon;
        }
    }, {
        key: 'validateValue',
        value: function validateValue(value) {
            if ('string' == typeof value && this.checkIfSelectedIconIsInIconsArray(value)) {
                return true;
            }
            return false;
        }
    }, {
        key: 'checkIfSelectedIconIsInIconsArray',
        value: function checkIfSelectedIconIsInIconsArray(icon) {
            /*
            * ~ = BITWISE NOT OPERATOR - https://stackoverflow.com/questions/12299665/what-does-a-tilde-do-when-it-precedes-an-expression
            */
            var result = false;
            if ('undefined' != typeof tatsuIcons) {
                result = Object.keys(tatsuIcons).some(function (iconName) {
                    if (null != tatsuIcons[iconName] && (0, _EditorHelpers.hasKeys)(tatsuIcons[iconName], 'icons')) {
                        return ~tatsuIcons[iconName].icons.indexOf(icon);
                    }
                    return false;
                });
            }
            return result;
        }
    }, {
        key: 'getCurrentIconKit',
        value: function getCurrentIconKit(selectedIcon) {
            if ('undefined' != typeof tatsuIcons && null != selectedIcon) {
                return Object.keys(tatsuIcons).find(function (iconName) {
                    if (null != tatsuIcons[iconName] && (0, _EditorHelpers.hasKeys)(tatsuIcons[iconName], 'title')) {
                        return ~tatsuIcons[iconName].icons.indexOf(selectedIcon);
                    }
                    return false;
                }) || 'all';
            }
            return 'all';
        }
    }, {
        key: 'checkIfIconkitIsPossible',
        value: function checkIfIconkitIsPossible(icons) {
            if ('[object Object]' == (0, _EditorHelpers.getObjectType)(icons)) {
                return Object.keys(icons).some(function (iconName) {
                    if ('null' != icons[iconName] && (0, _EditorHelpers.hasKeys)(icons[iconName], 'title')) {
                        return true;
                    }
                    return false;
                });
            }
            return false;
        }
    }, {
        key: 'getAvailableIconMap',
        value: function getAvailableIconMap() {
            var iconMap = {
                all: 'All'
            };
            if ('undefined' != typeof tatsuIcons) {
                if (this.checkIfIconkitIsPossible(tatsuIcons)) {
                    Object.keys(tatsuIcons).forEach(function (iconName) {
                        if (null != tatsuIcons[iconName] && (0, _EditorHelpers.hasKeys)(tatsuIcons[iconName], 'title')) {
                            iconMap[iconName] = tatsuIcons[iconName].title;
                        }
                    });
                    return iconMap;
                }
            }
            return false;
        }
    }, {
        key: 'changeHandler',
        value: function changeHandler(event) {
            this.setState({
                filter: event.target.value
            });
        }
    }, {
        key: 'cellClickHandler',
        value: function cellClickHandler(filteredCellClassName, event) {
            var selectedIconClass = filteredCellClassName,
                selected = this.state.selected;
            if (selectedIconClass != selected) {
                if ('clear' === selectedIconClass) {
                    this.setState({
                        selected: ''
                    });
                    this.props.onChange('');
                } else {
                    this.setState({
                        selected: selectedIconClass
                    });
                    this.props.onChange(selectedIconClass);
                }
            }
        }
    }, {
        key: 'closeHandler',
        value: function closeHandler(event) {
            this.setState({
                displayIconList: false
            });
        }
    }, {
        key: 'changeIconKit',
        value: function changeIconKit(e) {
            this.setState({
                iconKit: e
            });
        }
    }, {
        key: 'getIconArray',
        value: function getIconArray(data) {
            var iconsArray = [];
            if ('all' == data) {
                Object.keys(tatsuIcons).forEach(function (iconName) {
                    iconsArray = iconsArray.concat(tatsuIcons[iconName].icons);
                });
            } else {
                if (tatsuIcons.hasOwnProperty(data)) {
                    if ((0, _EditorHelpers.hasKeys)(tatsuIcons[data], 'icons')) {
                        iconsArray = iconsArray.concat(tatsuIcons[data].icons);
                    }
                }
            }
            return iconsArray;
        }
    }, {
        key: 'cellRenderer',
        value: function cellRenderer(classList, dataObject) {
            var columnIndex = dataObject.columnIndex,
                rowIndex = dataObject.rowIndex,
                style = dataObject.style,
                key = dataObject.key,
                newStyle = jQuery.extend({}, style, { display: 'table', textAlign: 'center', borderBottom: '1px solid #eaebec', borderRight: '1px solid #eaebec' });

style = jQuery.extend({}, style, { display: 'flex', justifyContent: 'center', alignItems: 'center' });
            if ('undefined' != typeof classList[rowIndex] && 'undefined' != typeof classList[rowIndex][columnIndex]) {
                var filteredCellClassName = classList[rowIndex][columnIndex],
                    activeAdder = '',
                    iconStyle = {
                    display: 'table-cell',
                    verticalAlign: 'middle',
                    color: 'inherit'
                };
                if ('oshine_diamond' == filteredCellClassName) {
                    iconStyle.color = '';
                    iconStyle.background = '#727b7d';
                    iconStyle.display = null;
                    iconStyle.position = 'absolute';
                    iconStyle.top = '50%';
                    iconStyle.left = '50%';
                    iconStyle.marginTop = '-5px';
                    iconStyle.marginLeft = '-5px';
                }
                if (this.state.selected === filteredCellClassName) {
                    if ('oshine_diamond' === filteredCellClassName) {
                        iconStyle.background = '#fff';
                    } else {
                        iconStyle.color = 'inherit';
                    }
                    var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';

newStyle.background = primaryColor;
                } else {
                    newStyle.background = '';
                }

return _react2.default.createElement(
                    'div',
                    { key: key, style: style, className: this.state.selected === filteredCellClassName ? 'selected' : '', onClick: this.cellClickHandler.bind(this, filteredCellClassName) },
                    'clear' !== filteredCellClassName ? _react2.default.createElement('i', { className: filteredCellClassName, style: iconStyle }) : this.getEmptyIcon()
                );
            } else {
                return null;
            }
        }
    }, {
        key: 'clickHandler',
        value: function clickHandler(event) {
            var currentState = this.state.displayIconList;
            this.setState({
                displayIconList: !currentState
            });
        }
    }, {
        key: 'getEmptyIcon',
        value: function getEmptyIcon() {
            return _react2.default.createElement(
                'svg',
                { className: 'tatsu-svg-icon icon-tatsu-close', viewBox: '0 0 24 24', version: '1.1', x: '0px', y: '0px' },
                _react2.default.createElement(
                    'g',
                    { transform: 'translate(0,-1028.3622)' },
                    _react2.default.createElement(
                        'g',
                        { transform: 'translate(-5e-5,1.0054688e-4)', fill: '#000000', 'fill-opacity': '1', stroke: 'none' },
                        _react2.default.createElement(
                            'g',
                            { transform: 'translate(0,3.9453125e-5)', fill: '#000000', 'fill-opacity': '1', stroke: 'none' },
                            _react2.default.createElement('path', { style: { fill: 'red' }, d: 'm -643.36133,504.67578 c -6.61557,0 -12,5.3845 -12,12 0,6.6156 5.38443,12 12,12 6.61557,0 12,-5.3844 12,-12 0,-6.6155 -5.38443,-12 -12,-12 z m -3.08594,7.5 3.08594,3.08594 3.08594,-3.08594 1.41406,1.41406 -3.08594,3.08594 3.08594,3.08594 -1.41406,1.41406 -3.08594,-3.08594 -3.08594,3.08594 -1.41406,-1.41406 3.08594,-3.08594 -3.08594,-3.08594 1.41406,-1.41406 z', transform: 'translate(655.36138,523.68628)' })
                        )
                    )
                )
            );
        }
    }, {
        key: 'render',
        value: function render() {
            var cName = (0, _EditorHelpers.getClassNames)('be-ui-component', 'be-icon-picker', this.props.className),
                currentSelectedIcon = this.state.selected != '' ? this.state.selected : this.getEmptyIcon(),
                selectOptions = this.getAvailableIconMap(),
                rowSize = void 0,
                label = this.props.label,
                scrollIndex = void 0,
                currentIconArray = this.getIconArray(this.state.iconKit),
                filteredArray = void 0,
                classList = void 0;
            if ('string' != typeof label) {
                label = 'Icon';
            }
            if ('' != this.state.filter) {
                filteredArray = currentIconArray.filter(function (element) {
                    if (-1 < element.toLowerCase().indexOf(this.state.filter.toLowerCase())) {
                        return true;
                    }
                }.bind(this));
                classList = (0, _EditorHelpers.convertToGrid)(filteredArray);
            } else {
                classList = (0, _EditorHelpers.convertToGrid)(currentIconArray);
            }
            rowSize = classList.length;
            if ('' == this.state.filter && '' != currentSelectedIcon && this.state.displayIconList) {
                classList.every(function (row, index) {
                    if (-1 < row.indexOf(currentSelectedIcon)) {
                        scrollIndex = index;
                        return false;
                    }
                    return true;
                });
            }

var currentNode = findDOMNode(this),
                curNodePosition = 0,
                top = 0,
                pickerHeight = 255;

if (currentNode) {
                curNodePosition = currentNode.getBoundingClientRect();
                if (window.innerHeight < curNodePosition.bottom + pickerHeight) {
                    if (0 > curNodePosition.top - pickerHeight) {
                        top = 0;
                    } else {
                        top = curNodePosition.top - pickerHeight - 10 + 'px';
                    }
                } else {
                    top = curNodePosition.top + 60 + 'px';
                }
            }

return _react2.default.createElement(
                'div',
                { className: "be-editor-field-set icon_picker " + cName },
                _react2.default.createElement(
                    'div',
                    { className: 'be-pb-icon-select', onClick: this.clickHandler },
                    _react2.default.createElement(
                        'div',
                        { className: 'be-icon-preview' },
                        '' === this.state.selected ? currentSelectedIcon : _react2.default.createElement('i', { className: currentSelectedIcon })
                    )
                ),
                this.state.displayIconList && _react2.default.createElement(
                    RenderToBody,
                    null,
                    _react2.default.createElement(
                        'div',
                        { className: 'be-pb-icon-loader-wrapper', style: { left: 25, top: top } },
                        _react2.default.createElement(
                            'div',
                            { className: 'be-pb-search-wrapper' },
                            _react2.default.createElement(
                                'div',
                                { className: 'be-pb-search' },
                                _react2.default.createElement(Search, {
                                    placeholder: 'Input Search Text',
                                    onChange: this.changeHandler,
                                    autoFocus: true
                                })
                            ),
                            _react2.default.createElement(_index2.default, { onChange: this.changeIconKit, options: selectOptions, value: this.state.iconKit })
                        ),
                        _react2.default.createElement(_Grid2.default, {
                            cellRenderer: this.cellRenderer.bind(this, classList),
                            columnWidth: 65,
                            columnCount: 4,
                            height: 140,
                            overscanRowCount: 0,
                            scrollToRow: 'undefined' === typeof scrollIndex ? 1 : scrollIndex,
                            rowHeight: 40,
                            rowCount: rowSize,
                            width: 262,
                            style: { outline: 'none', cursor: 'pointer' }
                        })
                    )
                ),
                this.state.displayIconList && _react2.default.createElement('div', { className: 'be-pb-fixed-wrapper', onClick: this.closeHandler })
            );
        }
    }]);

return IconPicker;
}(_react2.default.Component);

exports.default = IconPicker;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 647 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, $, jQuery) {

var SingleImageBlock = __webpack_require__(651),
    shortid = __webpack_require__(116),
    sendMessage = __webpack_require__(2).sendMessage,
    store = __webpack_require__(11);
var MultiImagePicker = React.createClass({
	displayName: 'MultiImagePicker',

mediaObject: null,
	type: null,
	eventsAdded: false,
	getMediaObject: function getMediaObject() {

this.mediaObject = wp.media({
			title: 'Select  the desired Images',
			button: {
				text: 'Done'
			},
			multiple: true, // Set to true to allow multiple files to be selected
			dragAndDrop: true
		});
	},

setPickerType: function setPickerType() {
		var pickerType = Immutable.Map.isMap(this.props.options) ? this.props.options.get('type') : false;
		if (pickerType) {
			this.type = pickerType;
		}
	},

getInitialState: function getInitialState() {

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = false;
		result = !Immutable.is(this.state.attachmentList, nextState.attachmentList);
		return result;
	},

_getUrlFromAttachment: function _getUrlFromAttachment(attachment) {

var size = Immutable.Map.isMap(this.props.options) ? this.props.options.get('size') : 'thumbnail';
		if (attachment.hasOwnProperty('sizes') && attachment.sizes.hasOwnProperty(size) && null != attachment.sizes[size]) {
			return attachment.sizes[size].url;
		} else {
			return attachment.url;
		}
	},

_getIdArray: function _getIdArray(attachmentList) {
		var idArray = [];
		attachmentList.forEach(function (attachmentContainer) {
			if ('both' == this.type) {
				idArray.push(attachmentContainer.get('id') + "::" + attachmentContainer.get('url'));
			} else {
				idArray.push(attachmentContainer.get('id'));
			}
		}.bind(this));
		return idArray;
	},

_handleAdd: function _handleAdd(event) {

var dragDropManager = this.context.dragDropManager;
		if (this.mediaObject == null) {
			this.getMediaObject();
		}
		if (!this.eventsAdded) {
			this.mediaObject.on('open', function (event) {

dragDropManager.backend.teardown();
			});
			this.mediaObject.on('close', function (event) {

dragDropManager.backend.setup();
			});
			this.mediaObject.on('select', function () {

_handleRemove: function _handleRemove(key, event) {

var currentAttachmentList = this.state.attachmentList,
		    deleteIndex = -1,
		    idArray = [];
		deleteIndex = currentAttachmentList.findIndex(function (attachmentContainer) {
			return key == attachmentContainer.get('key');
		});
		currentAttachmentList = currentAttachmentList.delete(deleteIndex);
		this.setState({
			attachmentList: currentAttachmentList
		});
		idArray = this._getIdArray(currentAttachmentList);
		this.props.onChange(idArray.toString(), 1);
	},

componentDidMount: function componentDidMount() {

var options = this.props.options;
		if (0 < this.state.attachmentList.size && 'both' != this.type) {

var idArray = [],
			    attachmentList = this.state.attachmentList;
			idArray = this._getIdArray(attachmentList);
			var jsonData = JSON.stringify(idArray);

this.serverRequest = $.ajax({
				type: 'POST',
				dataType: 'json',
				//url : tatsuConfig.restapiurl + 'get_images',
				url: tatsuConfig.ajaxurl,
				data: {
					action: 'tatsu_get_images_from_id',
					images: jsonData,
					size: 'thumbnail',
					nonce: tatsuConfig.nonce
				},
				beforeSend: function beforeSend(xhr) {
					xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
				}
			}).then(function (urlObject) {

attachmentList = attachmentList.map(function (attachmentContainer) {
					if ('' == attachmentContainer.get('url') && '' != urlObject[attachmentContainer.get('id')]) {
						return attachmentContainer.set('url', urlObject[attachmentContainer.get('id')]);
					}
					return attachmentContainer;
				});
				this.setState({
					attachmentList: attachmentList
				});
			}.bind(this)).catch(function (error) {

store.dispatch(sendMessage("Unable to fetch the images", "error"));
				console.log(error);
			});
		}
	},

_triggerChange: function _triggerChange() {

var currentAttachmentList = this.state.attachmentList,
		    idArray = this._getIdArray(currentAttachmentList);
		this.props.onChange(idArray.toString(), 0);
	},

_getState: function _getState() {

var currentAttachmentList = this.state.attachmentList;
		return currentAttachmentList;
	},

_setState: function _setState(newAttachmentList) {

this.setState({
			attachmentList: newAttachmentList
		});
	},

componentWillUnmount: function componentWillUnmount() {

if ('undefined' != typeof this.serverRequest) {
			delete this.serverRequest;
		}
		if (null != this.mediaObject) {
			this.mediaObject.off('select');
			this.mediaObject = null;
		}
	},

_handleReorder: function _handleReorder(draggedImageAttachmentKey, hoveredImageAttachmentKey) {

_reverseImages: function _reverseImages() {
		var attachmentList = this.state.attachmentList,
		    reversedList = attachmentList.reverse(),
		    idArray = this._getIdArray(reversedList);
		this.setState({ attachmentList: reversedList });
		this.props.onChange(idArray.toString(), 1);
	},

render: function render() {

var attachmentList = this.state.attachmentList;
		var primaryColor = jQuery('body').hasClass('tatsu-theme-dark') ? '#00b4ff' : '#1b86f1';

return React.createElement(
			'div',
			{ className: 'be-pb-multi-wrapper' },
			attachmentList.map(function (attachmentContainer, index) {
				var completeUrl = '' == attachmentContainer.get('url') ? '' : 'url(' + attachmentContainer.get('url') + ')';
				return React.createElement(SingleImageBlock, { key: attachmentContainer.get('key'), _getState: this._getState, _setState: this._setState, index: index, attachmentKey: attachmentContainer.get('key'), _triggerChange: this._triggerChange, _handleRemove: this._handleRemove, _handleReorder: this._handleReorder, url: completeUrl });
			}.bind(this)),
			React.createElement(
				'div',
				{ className: 'be-pb-single-image-adder', style: { width: '60px', height: '60px', position: 'relative', display: 'inline-block' }, onClick: this._handleAdd },
				React.createElement(
					'svg',
					{ className: 'tatsu-svg-icon', viewBox: '0 0 20 20' },
					React.createElement('path', { fill: primaryColor, d: 'M13.388,9.624h-3.011v-3.01c0-0.208-0.168-0.377-0.376-0.377S9.624,6.405,9.624,6.613v3.01H6.613c-0.208,0-0.376,0.168-0.376,0.376s0.168,0.376,0.376,0.376h3.011v3.01c0,0.208,0.168,0.378,0.376,0.378s0.376-0.17,0.376-0.378v-3.01h3.011c0.207,0,0.377-0.168,0.377-0.376S13.595,9.624,13.388,9.624z M10,1.344c-4.781,0-8.656,3.875-8.656,8.656c0,4.781,3.875,8.656,8.656,8.656c4.781,0,8.656-3.875,8.656-8.656C18.656,5.219,14.781,1.344,10,1.344z M10,17.903c-4.365,0-7.904-3.538-7.904-7.903S5.635,2.096,10,2.096S17.903,5.635,17.903,10S14.365,17.903,10,17.903z' })
				)
			),
			0 < attachmentList.size ? React.createElement(
				'div',
				{ className: 'be-pb-multi-reverse-images', onClick: this._reverseImages },
				'Reverse Order'
			) : null
		);
	}

});
MultiImagePicker.contextTypes = {
	dragDropManager: React.PropTypes.object.isRequired
};
module.exports = MultiImagePicker;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4), __webpack_require__(4)))

/***/ }),
/* 648 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _reactDom = __webpack_require__(7);

var _reactDom2 = _interopRequireDefault(_reactDom);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var RenderToBody = function (_React$Component) {
    _inherits(RenderToBody, _React$Component);

function RenderToBody() {
        _classCallCheck(this, RenderToBody);

return _possibleConstructorReturn(this, (RenderToBody.__proto__ || Object.getPrototypeOf(RenderToBody)).apply(this, arguments));
    }

_createClass(RenderToBody, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
            this.popup = document.createElement('div');
            document.body.appendChild(this.popup);
            this.__render();
        }
    }, {
        key: '__render',
        value: function __render() {
            if (this.popup) {
                _reactDom2.default.render(this.props.children, this.popup);
            }
        }
    }, {
        key: 'componentDidUpdate',
        value: function componentDidUpdate() {
            this.__render();
        }
    }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            _reactDom2.default.unmountComponentAtNode(this.popup);
            document.body.removeChild(this.popup);
        }
    }, {
        key: 'render',
        value: function render() {
            return null;
        }
    }]);

return RenderToBody;
}(React.Component);

exports.default = RenderToBody;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 649 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _index = __webpack_require__(211);

var _index2 = _interopRequireDefault(_index);

var _EditorConstants = __webpack_require__(95);

var _EditorHelpers = __webpack_require__(26);

__webpack_require__(894);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ScreenVisibility = function ScreenVisibility(props) {
    return React.createElement(_index2.default, {
        isAjax: props.isAjax,
        onChange: props.onChange,
        width: props.width,
        className: (0, _EditorHelpers.getClassNames)("be-ui-screenvisibility", props.className),
        options: _EditorConstants.screenVisibilityOption,
        value: props.value || ''
    });
};

exports.default = ScreenVisibility;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 650 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _select = __webpack_require__(65);

var _select2 = _interopRequireDefault(_select);

__webpack_require__(66);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

__webpack_require__(895);

var _EditorHelpers = __webpack_require__(26);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Option = _select2.default.Option;

var BeSelectImage = function (_React$Component) {
    _inherits(BeSelectImage, _React$Component);

function BeSelectImage(props) {
        _classCallCheck(this, BeSelectImage);

var _this = _possibleConstructorReturn(this, (BeSelectImage.__proto__ || Object.getPrototypeOf(BeSelectImage)).call(this, props));

_this.state = {
            value: _this.props.value || ''
        };
        _this.changeHandler = _this.changeHandler.bind(_this);
        return _this;
    }

_createClass(BeSelectImage, [{
        key: 'validateOptions',
        value: function validateOptions() {
            if ((0, _EditorHelpers.validateValues)(this.props.options)) {
                this.options = this.props.options;
            } else {
                this.options = null;
            }
        }
    }, {
        key: 'componentWillMount',
        value: function componentWillMount() {
            if (!this.options) {
                this.validateOptions();
            }
        }
    }, {
        key: 'changeHandler',
        value: function changeHandler(value) {
            this.setState({
                value: value
            });
        }
    }, {
        key: 'render',
        value: function render() {
            return _react2.default.createElement(
                'div',
                { className: (this.props.className || '') + ' be-select-image be-ui-component' },
                _react2.default.createElement(
                    _select2.default,
                    { dropdownClassName: 'be-select-image-dropdown', value: this.state.value, onSelect: this.changeHandler, getPopupContainer: function getPopupContainer(triggerNode) {
                            return triggerNode.parentNode;
                        } },
                    this.options && ('[object Object]' == (0, _EditorHelpers.getObjectType)(this.options) ? Object.keys(this.options).map(function (key) {
                        return _react2.default.createElement(
                            Option,
                            { value: key },
                            _react2.default.createElement('img', { src: this.options[key] })
                        );
                    }.bind(this)) : this.options.map(function (value, key) {
                        return _react2.default.createElement(
                            Option,
                            { value: key },
                            _react2.default.createElement('img', { src: value })
                        );
                    }.bind(this)))
                )
            );
        }
    }]);

return BeSelectImage;
}(_react2.default.Component);

exports.default = BeSelectImage;

/***/ }),
/* 651 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, React) {

var DragSource = __webpack_require__(37).DragSource,
    DropTarget = __webpack_require__(37).DropTarget,
    findDOMNode = __webpack_require__(7).findDOMNode,
    flow = __webpack_require__(60),
    dndScope = __webpack_require__(79).multiImageDnDConstant;

var dragSpecification = {

beginDrag: function beginDrag(props) {

return {
			index: props.index,
			attachmentKey: props.attachmentKey,
			attachmentList: props._getState()
		};
	},

endDrag: function endDrag(props, monitor) {

isDragging: function isDragging(props, monitor) {

if (props.index === monitor.getItem().index) {
			return true;
		} else {
			return false;
		}
	}

};

var dropSpecification = {

drop: function drop(props, monitor) {

return {
			trigger: 1
		};
	},

hover: function hover(props, monitor, component) {

};

function dragSourceCollect(connect, monitor) {

return {
		connectDragSource: connect.dragSource(),
		isDragging: monitor.isDragging()
	};
}

function dropTargetCollect(connect, monitor) {

return {
		connectDropTarget: connect.dropTarget(),
		isOver: monitor.isOver(),
		canDrop: monitor.canDrop()
	};
}

var SingleImageBlock = React.createClass({
	displayName: 'SingleImageBlock',

render: function render() {

var connectDragSource = this.props.connectDragSource,
		    connectDropTarget = this.props.connectDropTarget,
		    isDragging = this.props.isDragging,
		    canDrop = this.props.canDrop,
		    isOver = this.props.isOver,
		    attachmentKey = this.props.attachmentKey,
		    completeUrl = this.props.url;
		return connectDragSource(connectDropTarget(React.createElement(
			'div',
			{ onClick: this.props._handleRemove.bind(null, attachmentKey), className: 'be-pb-single-image-wrapper', style: { backgroundImage: '' == completeUrl ? null : completeUrl, opacity: isDragging ? '0' : '1' } },
			React.createElement(
				'svg',
				{ className: 'tatsu-svg-icon icon-tatsu-close', viewBox: '0 0 24 24', version: '1.1', x: '0px', y: '0px' },
				React.createElement(
					'g',
					{ transform: 'translate(0,-1028.3622)' },
					React.createElement(
						'g',
						{ transform: 'translate(-5e-5,1.0054688e-4)', fill: '#000000', 'fill-opacity': '1', stroke: 'none' },
						React.createElement(
							'g',
							{ transform: 'translate(0,3.9453125e-5)', fill: '#000000', 'fill-opacity': '1', stroke: 'none' },
							React.createElement('path', { style: { fill: 'red' }, d: 'm -643.36133,504.67578 c -6.61557,0 -12,5.3845 -12,12 0,6.6156 5.38443,12 12,12 6.61557,0 12,-5.3844 12,-12 0,-6.6155 -5.38443,-12 -12,-12 z m -3.08594,7.5 3.08594,3.08594 3.08594,-3.08594 1.41406,1.41406 -3.08594,3.08594 3.08594,3.08594 -1.41406,1.41406 -3.08594,-3.08594 -3.08594,3.08594 -1.41406,-1.41406 3.08594,-3.08594 -3.08594,-3.08594 1.41406,-1.41406 z', transform: 'translate(655.36138,523.68628)' })
						)
					)
				)
			),
			'' == completeUrl ? React.createElement('div', { className: 'tatsu-loader' }) : null
		)));
	}

});

module.exports = flow(DragSource(dndScope.module, dragSpecification, dragSourceCollect), DropTarget(dndScope.module, dropSpecification, dropTargetCollect))(SingleImageBlock);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0)))

/***/ }),
/* 652 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

__webpack_require__(897);
var SingleImagePicker = React.createClass({
	displayName: 'SingleImagePicker',

mediaObject: null,
	eventsAdded: false,
	getMediaObject: function getMediaObject() {
		var popupTitle = Immutable.Map.isMap(this.props.options) && 'string' == typeof this.props.options.get('modal_title') ? this.props.options.get('modal_title') : 'Select a Background Image',
		    buttonText = Immutable.Map.isMap(this.props.options) && 'string' == typeof this.props.options.get('button_text') ? this.props.options.get('button_text') : 'Set as Background Image',
		    mimeType = Immutable.Map.isMap(this.props.options) && 'string' == typeof this.props.options.get('mime_type') ? this.props.options.get('mime_type') : 'image',
		    parsedMimeType = [];
		mimeType.split(',').reduce(function (parsedMimeType, curType) {
			curType = curType.trim();
			if ('' != curType) {
				parsedMimeType.push(curType);
			}
		}, parsedMimeType);
		this.mediaObject = wp.media({
			title: popupTitle,
			button: {
				text: buttonText
			},
			library: {
				type: parsedMimeType
			},
			multiple: false, // Set to true to allow multiple files to be selected
			dragAndDrop: true
		});
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
		var newAttachmenturl = nextProps.value;
		if (newAttachmenturl != this.state.attachmenturl) {
			this.setState({
				attachmenturl: newAttachmenturl
			});
		}
	},

componentDidMount: function componentDidMount() {
		var dragDropManager = this.context.dragDropManager,
		    size = Immutable.Map.isMap(this.props.options) && 'string' == typeof this.props.options.get('size') ? this.props.options.get('size') : 'full';
		this.getMediaObject();
		if (null != this.mediaObject) {
			this.mediaObject.on('open', function (event) {
				dragDropManager.backend.teardown();
			});
			this.mediaObject.on('close', function (event) {
				dragDropManager.backend.setup();
			});
			this.mediaObject.on('select', function () {
				var attachment = this.mediaObject.state().get('selection').first().toJSON(),
				    url;
				if ('svg' !== attachment.url.substr(attachment.url.length - 3) && 'undefined' != typeof attachment.sizes[size]) {
					url = attachment.sizes[size].url;
				} else {
					url = attachment.url;
				}
				if ('tatsu_image' == this.props.moduleName) {
					this.props.onChange({
						targetAtt: 'id',
						value: attachment.id
					}, 0);
				} else if ('tatsu_multi_layer_image' === this.props.moduleName) {
					this.props.onChange({
						targetAtt: 'id',
						value: attachment.id
					}, 0);
				}
				this.props.onChange(url, 1);
			}.bind(this));
		}
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
		var result = true;
		result = !(this.props.value === nextProps.value && Immutable.is(this.props.options, nextProps.options));
		return result;
	},

getInitialState: function getInitialState() {
		var initialAttachment = this.props.value;
		return {
			attachmenturl: initialAttachment
		};
	},

componentWillUnMount: function componentWillUnMount() {
		if (null != this.mediaObject) {
			this.mediaObject.off();
			this.mediaObject = null;
		}
	},

_handleAdd: function _handleAdd(event) {
		// var dragDropManager = this.context.dragDropManager;
		// if(this.mediaObject == null) {
		// 	this.getMediaObject();
		// }
		// if( !this.eventsAdded ) {
		// 	this.mediaObject.on('open', function( event ) {

// 		dragDropManager.backend.teardown();

// 	} );
		// 	this.mediaObject.on( 'close', function( event ) {

// 		dragDropManager.backend.setup();

// 	} );
		// 	this.mediaObject.on('select',function(){
		// 		var attachment = this.mediaObject.state().get('selection').first().toJSON(),
		// 			url;
		// 		if( 'svg' !== attachment.url.substr(attachment.url.length - 3) &&  'undefined' != typeof attachment.sizes[ size ] ) {
		// 			url = attachment.sizes[ size ].url;
		// 		}else{
		// 			url = attachment.url;
		// 		}
		// 		if( 'tatsu_image' == this.props.moduleName ) {
		// 			this.props.onChange(
		// 				{
		// 					targetAtt : 'id',
		// 					value : attachment.id
		// 				},
		// 				0
		// 			);
		// 		}
		// 		this.props.onChange( url, 1 );

// 	}.bind(this));		
		// 	this.eventsAdded = true;	
		// }
		if (null != this.mediaObject) {
			this.mediaObject.open();
		}
	},

_handleRemove: function _handleRemove(event) {
		if ('tatsu_image' == this.props.moduleName) {
			this.props.onChange({
				targetAtt: 'id',
				value: ''
			}, 0);
			this.props.onChange({
				targetAtt: 'size',
				value: 'full'
			}, 0);
		} else if ('tatsu_multi_layer_image' == this.props.moduleName) {
			this.props.onChange({
				targetAtt: 'id',
				value: ''
			}, 0);
		}
		this.props.onChange('', 1);
	},

renderHelper: function renderHelper() {
		if (this.state.attachmenturl === '') {
			return React.createElement(
				'div',
				{ className: 'be-pb-single-image-picker be-pb-single-image-add', onClick: this._handleAdd },
				React.createElement(
					'div',
					{ className: 'tatsu-single-image-add-plus-icon' },
					React.createElement('span', { className: 'tatsu-single-image-add-plus-icon-vert' }),
					React.createElement('span', { className: 'tatsu-single-image-add-plus-icon-hor' })
				)
			);
		} else {
			var completeUrl = 'url(' + this.state.attachmenturl + ')';
			return React.createElement(
				'div',
				{ className: 'be-pb-single-image-picker be-pb-single-image-close', style: { backgroundImage: completeUrl }, onClick: this._handleRemove },
				React.createElement(
					'svg',
					{ className: 'tatsu-svg-icon icon-tatsu-close', viewBox: '0 0 24 24', version: '1.1', x: '0px', y: '0px' },
					React.createElement(
						'g',
						{ transform: 'translate(0,-1028.3622)' },
						React.createElement(
							'g',
							{ transform: 'translate(-5e-5,1.0054688e-4)', 'fill-opacity': '1', stroke: 'none' },
							React.createElement(
								'g',
								{ transform: 'translate(0,3.9453125e-5)', 'fill-opacity': '1', stroke: 'none' },
								React.createElement('path', { d: 'm -643.36133,504.67578 c -6.61557,0 -12,5.3845 -12,12 0,6.6156 5.38443,12 12,12 6.61557,0 12,-5.3844 12,-12 0,-6.6155 -5.38443,-12 -12,-12 z m -3.08594,7.5 3.08594,3.08594 3.08594,-3.08594 1.41406,1.41406 -3.08594,3.08594 3.08594,3.08594 -1.41406,1.41406 -3.08594,-3.08594 -3.08594,3.08594 -1.41406,-1.41406 3.08594,-3.08594 -3.08594,-3.08594 1.41406,-1.41406 z', transform: 'translate(655.36138,523.68628)' })
							)
						)
					)
				)
			);
		}
	},

render: function render() {
		var currentData = this.renderHelper();
		return currentData;
	}

});
SingleImagePicker.contextTypes = {
	dragDropManager: React.PropTypes.object.isRequired
};
module.exports = SingleImagePicker;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 653 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, jQuery) {

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _input = __webpack_require__(77);

var _input2 = _interopRequireDefault(_input);

__webpack_require__(78);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var React = __webpack_require__(0),
    convertToGrid = __webpack_require__(693).convertToGrid,
    isEqual = __webpack_require__(86),
    RenderToBody = __webpack_require__(125),
    findDOMNode = ReactDOM.findDOMNode,
    SelectComponent = __webpack_require__(93).default,
    Grid = __webpack_require__(314).Grid;
Immutable = __webpack_require__(3);

__webpack_require__(899);

var Search = _input2.default.Search;

var SvgIconPicker = React.createClass({
	displayName: 'SvgIconPicker',

checkIfSelectedIconIsInIconsArray: function checkIfSelectedIconIsInIconsArray(iconSet, data) {

var result = false;
		for (var fontArray in tatsuSvgs) {

if (-1 < tatsuSvgs[iconSet].icons.indexOf(data)) {
				//tatsuSvgs[fontArray].icons.indexOf( data )
				return true;
			}
			return false;
		}
		return result;
	},

validateValue: function validateValue(iconSet, data) {
		var result = true;
		if ('undefined' === typeof data || 'undefined' === typeof iconSet || !tatsuSvgs.hasOwnProperty(iconSet) || !(-1 < tatsuSvgs[iconSet].icons.indexOf(data))) {
			result = false;
		}
		return result;
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
		var newValue = '',
		    value = nextProps.value.split(':'),
		    existingValue = this.props.value.split(':');
		newValue = value[1];
		if (newValue != existingValue[1]) {
			var selectedIconKit = newValue ? this._getCurrentIconKit(newValue) : 'All',
			    selectedIconClass = newValue ? newValue : '';
			this.setState({
				selected: selectedIconClass,
				iconKit: selectedIconKit
			});
		}
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
		result = !(this.props.value === nextProps.value && isEqual(this.state, nextState));
		return result;
	},

getInitialState: function getInitialState() {
		// [0] => 'iconKit', [1] => 'svgIcon'
		var value = this.props.value.split(':'),
		    currentSelected = '',
		    initialIconKit = 'All';
		if (this.validateValue(value[0], value[1])) {
			currentSelected = value[1];
			initialIconKit = value[0];
		}

return {
			displayIconList: false,
			iconKit: initialIconKit,
			selected: currentSelected,
			filter: ''
		};
	},

_validateIconKit: function _validateIconKit(iconKit) {

return tatsuSvgs.hasOwnProperty(iconKit);
	},

_validateIconWithKit: function _validateIconWithKit(iconKit, icon) {

return -1 < tatsuSvgs[iconKit].icons.indexOf(icon);
	},

_IconBelongsTo: function _IconBelongsTo(icon) {

for (var fontArray in tatsuSvgs) {

if (this._validateIconKit(fontArray) && this._validateIconWithKit(fontArray, icon)) {
				return fontArray;
			}
		}
		return 'All';
	},

_getAvailableIconMap: function _getAvailableIconMap() {

var IconOptions = Immutable.Map(),
		    count = 0;

IconOptions = IconOptions.set('All', 'All');
		for (var fontArray in tatsuSvgs) {
			if (this._validateIconKit(fontArray)) {
				IconOptions = IconOptions.set(fontArray, tatsuSvgs[fontArray].title); //	IconOptions = IconOptions.set( fontArray, tatsuSvgs[fontArray].title );
			}
		}

return IconOptions;
	},

_getCurrentIconKit: function _getCurrentIconKit(selectedValue) {

for (var fontArray in tatsuSvgs) {
			if (tatsuSvgs.hasOwnProperty(fontArray)) {
				if (-1 < tatsuSvgs[fontArray].icons.indexOf(selectedValue)) {
					// tatsuSvgs[fontArray].icons.indexOf( selectedValue )
					return fontArray; // change it to tatsuSvgs[fontArray].title
				}
			}
		}
		return 'All';
	},

_changeHandler: function _changeHandler(event) {

this.setState({
			filter: event.target.value
		});
	},

_cellClickHandler: function _cellClickHandler(filteredCellClassName, event) {

_closeHandler: function _closeHandler(event) {

this.setState({
			displayIconList: false
		});
	},

_getIconArray: function _getIconArray(data) {

var iconsArray = [];

if ('All' === data) {
			for (var fontArray in tatsuSvgs) {
				iconsArray = iconsArray.concat(tatsuSvgs[fontArray].icons); //  	iconsArray.concat( tatsuSvgs[fontArray].icons
			}
		} else {
			for (var _fontArray in tatsuSvgs) {
				if (tatsuSvgs.hasOwnProperty(_fontArray)) {
					if (data === _fontArray) {
						// datat = tatsuSvgs[fontArray].title
						return tatsuSvgs[_fontArray].icons; // return tatsuSvgs[ fontArray ].icons
					}
				}
			}
		}
		return iconsArray;
	},

_cellRenderer: function _cellRenderer(classList, dataObject) {

_selectIconKit: function _selectIconKit(value) {

if (this._validateIconKit(value)) {
			var iconKit = value,
			    selected = tatsuSvgs[value]['icons'][0];
			this.setState({
				iconKit: iconKit,
				selected: selected
			});
			this.props.onChange(iconKit + ':' + selected, 1);
		} else {
			this.setState({
				iconKit: value,
				selected: this.state.selected
			});
		}
	},

_clearIcon: function _clearIcon(event) {

this.props.onChange('', 1);
	},

_clickHandler: function _clickHandler(event) {

var currentState = this.state.displayIconList;
		this.setState({
			displayIconList: !currentState
		});
	},

_getEmptyIcon: function _getEmptyIcon() {

return React.createElement(
			'svg',
			{ className: 'tatsu-svg-icon icon-tatsu-close', xmlns: 'http://www.w3.org/2000/svg', viewBox: '0 0 24 24', version: '1.1', x: '0px', y: '0px' },
			React.createElement(
				'g',
				{ transform: 'translate(0,-1028.3622)' },
				React.createElement(
					'g',
					{ transform: 'translate(-5e-5,1.0054688e-4)', fill: '#000000', fillOpacity: '1', stroke: 'none' },
					React.createElement(
						'g',
						{ transform: 'translate(0,3.9453125e-5)', fill: '#000000', fillOpacity: '1', stroke: 'none' },
						React.createElement('path', { style: { fill: 'red' }, d: 'm -643.36133,504.67578 c -6.61557,0 -12,5.3845 -12,12 0,6.6156 5.38443,12 12,12 6.61557,0 12,-5.3844 12,-12 0,-6.6155 -5.38443,-12 -12,-12 z m -3.08594,7.5 3.08594,3.08594 3.08594,-3.08594 1.41406,1.41406 -3.08594,3.08594 3.08594,3.08594 -1.41406,1.41406 -3.08594,-3.08594 -3.08594,3.08594 -1.41406,-1.41406 3.08594,-3.08594 -3.08594,-3.08594 1.41406,-1.41406 z', transform: 'translate(655.36138,523.68628)' })
					)
				)
			)
		);
	},

render: function render() {

var cName = this.props.className || '',
		    currentSelectedIcon = this.state.selected != '' ? this.state.selected : this._getEmptyIcon(),
		    currentIconKit = this._validateIconKit(this.state.iconKit) ? this.state.iconKit : '',
		    selectOptions = this._getAvailableIconMap(),
		    rowSize,
		    label = this.props.label,
		    scrollIndex,
		    currentIconArray = this._getIconArray(this.state.iconKit),
		    filteredArray,
		    classList;
		if ('string' != typeof label) {
			label = 'Svg Icon';
		}

if ('' != this.state.filter) {
			filteredArray = currentIconArray.filter(function (element) {
				if (-1 < element.toLowerCase().indexOf(this.state.filter.toLowerCase())) {
					return true;
				}
			}.bind(this));
			classList = convertToGrid(filteredArray);
		} else {
			classList = convertToGrid(currentIconArray);
		}

rowSize = classList.size;
		if ('' === this.state.filter && '' != currentSelectedIcon && this.state.displayIconList) {
			classList.every(function (row, index) {
				if (row.contains(currentSelectedIcon)) {
					scrollIndex = index;
					return false;
				}
				return true;
			});
		}

var iconLink, temp;
		if (currentIconKit) {
			iconLink = tatsuSvgs[currentIconKit]['link'] + [currentIconKit] + '.svg#' + currentSelectedIcon;
		} else {
			if ('' !== this.state.selected) {
				temp = this._getCurrentIconKit(this.state.selected);
				iconLink = tatsuSvgs[temp]['link'] + [temp] + '.svg#' + currentSelectedIcon;
			} else {
				iconLink = 'holo';
			}
		}

selectOptions = Immutable.fromJS(selectOptions);

var currentNode = findDOMNode(this),
		    curNodePosition = 0,
		    top = 0,
		    pickerHeight = 255;

return React.createElement(
			'li',
			{ className: "be-editor-field-set icon_picker " + cName },
			React.createElement(
				'div',
				{ className: 'be-pb-icon-select', onClick: this._clickHandler },
				React.createElement(
					'div',
					{ className: 'be-icon-preview' },
					'' === this.state.selected ? currentSelectedIcon : React.createElement(
						'svg',
						{ style: { height: '20px', width: '20px' }, fill: 'none', xmlns: 'http://www.w3.org/2000/svg', viewBox: '0 0 100 100' },
						React.createElement('use', { href: iconLink })
					)
				)
			),
			React.createElement(
				RenderToBody,
				null,
				React.createElement(
					'div',
					{ className: 'be-pb-icon-loader-wrapper', style: { display: this.state.displayIconList ? 'block' : 'none', top: top } },
					React.createElement(
						'div',
						{ className: 'be-pb-search-wrapper' },
						React.createElement(
							'div',
							{ className: 'be-pb-search' },
							React.createElement(
								'div',
								{ className: 'tatsu-search-inner-wrapper' },
								React.createElement(Search, { placeholder: 'Search', onChange: this._changeHandler, autoFocus: true })
							)
						),
						React.createElement(SelectComponent, { atts: this.props.atts, options: selectOptions, value: this.state.iconKit, floatingTextLabel: 'Icon Kits', onChange: this._selectIconKit })
					),
					React.createElement(Grid, {
						cellRenderer: this._cellRenderer.bind(null, classList),
						columnWidth: 65,
						columnCount: 4,
						height: 140,
						overscanRowCount: 0,
						scrollToRow: 'undefined' === typeof scrollIndex ? 1 : scrollIndex,
						rowHeight: 40,
						rowCount: rowSize,
						width: 262,
						style: { outline: 'none', cursor: 'pointer' }
					})
				)
			),
			React.createElement('div', { className: 'be-pb-fixed-wrapper', style: { display: this.state.displayIconList ? 'block' : 'none' }, onClick: this._closeHandler })
		);
	}

});
exports.default = SvgIconPicker;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 654 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _switch = __webpack_require__(209);

var _switch2 = _interopRequireDefault(_switch);

__webpack_require__(210);

var _EditorHelpers = __webpack_require__(26);

__webpack_require__(900);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function BeSwitchValueFormatter(changeHandler, value) {
    if (value) {
        changeHandler('1');
    } else {
        changeHandler('0');
    }
}

exports.default = BeSwitch;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 655 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

var _modal = __webpack_require__(118);

var _modal2 = _interopRequireDefault(_modal);

var _select = __webpack_require__(65);

var _select2 = _interopRequireDefault(_select);

__webpack_require__(119);

__webpack_require__(66);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Option = _select2.default.Option,
    OptGroup = _select2.default.OptGroup;

var React = __webpack_require__(0),
    findDOMNode = __webpack_require__(7).findDOMNode,
    typewatch = __webpack_require__(122);
__webpack_require__(901);

function renderTitle(title) {
	return React.createElement(
		'span',
		{ className: 'be-optgroup-title' },
		title
	);
}

var TatsuEditor = React.createClass({
	displayName: 'TatsuEditor',

initialized: false,

getInitialState: function getInitialState() {
		return {
			visible: false,
			editor: '',
			selected: ''
		};
	},

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
		var result = true;
		result = !(this.props.value === nextProps.value && this.state.visible === nextState.visible);
		return result;
	},

validateContent: function validateContent(value) {
		var result = true;
		if ('string' != typeof value) {
			result = false;
		}
		return result;
	},

componentDidMount: function componentDidMount() {

if (!this.props.isAjax && 'testimonial' != this.props.moduleName && 'content_slide' != this.props.moduleName) {
					editor.setContent(e.target.value);
					this.props.onChange(editor.getContent(), 0);
				} else {
					editor.setContent(e.target.value);
					typewatch(this.props.onChange.bind(null, editor.getContent(), 0), 700);
				}
			}.bind(this));

var isDynamic = false;
			if (this.props.moduleOptions && 'undefined' !== this.props.moduleOptions && this.props.moduleName && 'undefined' !== this.props.moduleName) {
				isDynamic = this.props.moduleOptions.getIn([this.props.moduleName, 'is_dynamic']);
			}
			if (isDynamic) {
				jQuery('.wp-editor-tabs').append('<button type="button" id="tatsu_editor-dynamic" class="wp-switch-editor"><svg viewBox="64 64 896 896" focusable="false" class="" data-icon="database" width="1em" height="1em" fill="currentColor" aria-hidden="true"><path d="M832 64H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V96c0-17.7-14.3-32-32-32zm-600 72h560v208H232V136zm560 480H232V408h560v208zm0 272H232V680h560v208zM304 240a40 40 0 1 0 80 0 40 40 0 1 0-80 0zm0 272a40 40 0 1 0 80 0 40 40 0 1 0-80 0zm0 272a40 40 0 1 0 80 0 40 40 0 1 0-80 0z"></path></svg></button>');
			}

jQuery('.wp-editor-tabs').on('click', function () {
				setTimeout(function () {
					editor.save();
				}, 0);
			});

jQuery('#tatsu_editor-dynamic').on('click', function () {
				self.setState({
					visible: true,
					editor: editor
				});
			}.bind(this));
		}.bind(this);

this.newObject.setup = function (editor) {
			editor.on('keyup change', function (editor, event) {
				var name = this.props.moduleName;
				if (this.deleteIndicator === 1) {
					return;
				}
				if (!this.props.isAjax && 'testimonial' != name && 'content_slide' != name) {
					editor.save();
					this.props.onChange(editor.getContent(), 0);
				} else {
					editor.save();
					typewatch(this.props.onChange.bind(null, editor.getContent(), 0), 700);
				}
			}.bind(this, editor));
		}.bind(this);

if (null != tinySaver) {
			tinySaver.style.display = 'block';
		}
		if (null != parentTinySaver) {
			parentTinySaver.style.display = 'block';
		}
		tinyMCE.init(this.newObject);
	},

componentWillUnmount: function componentWillUnmount() {
		this.deleteIndicator = 1;
		if (this.initialized) {
			tinyMCE.get('tatsu_editor').remove();
			this.newObject = {};
		}
	},

createMarkup: function createMarkup() {
		return { __html: tatsuConfig.wp_editor };
	},

handleChange: function handleChange(value) {
		this.setState({
			selected: value
		});
	},
	handleUpdate: function handleUpdate() {
		this.state.editor.insertContent('[tatsu_dynamic_field data="' + this.state.selected + '"]');
		this.setState({
			visible: false,
			editor: ''
		});
	},

handleCancel: function handleCancel() {
		this.setState({
			visible: false
		});
	},

render: function render() {
		var dataSource = tatsuConfig.fields || [];
		var dataOptions = dataSource.map(function (group) {
			return React.createElement(
				OptGroup,
				{ key: group.title, label: renderTitle(group.title) },
				group.fields.map(function (opt) {
					return React.createElement(
						Option,
						{ key: opt.value, value: opt.value },
						opt.text
					);
				})
			);
		});

return React.createElement(
			'div',
			null,
			React.createElement('div', { id: 'tatsu-parent-tinymce-helper' }),
			React.createElement('div', { dangerouslySetInnerHTML: this.createMarkup() }),
			React.createElement(
				_modal2.default,
				{
					title: 'Insert Dynamic Field',
					visible: this.state.visible,
					okText: 'Insert',
					onOk: this.handleUpdate,
					onCancel: this.handleCancel,
					width: 400
				},
				React.createElement(
					_select2.default,
					{ onChange: this.handleChange, defaultValue: '-- Select --', style: { width: '100%' } },
					dataOptions
				)
			)
		);
	}

});
module.exports = TatsuEditor;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 656 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _input = __webpack_require__(77);

var _input2 = _interopRequireDefault(_input);

__webpack_require__(78);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var typewatch = __webpack_require__(122);

var AntTextArea = _input2.default.TextArea;

var TextArea = React.createClass({
    displayName: 'TextArea',

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

var newValue = nextProps.value;
        if (newValue != this.props.value) {
            this.setState({
                textContent: newValue
            });
        }
    },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
        result = !(this.props.value === nextProps.value && this.state.textContent === nextState.textContent);
        return result;
    },

getInitialState: function getInitialState() {

var value = '';
        if (this.validateValue(this.props.value)) {
            value = this.props.value;
        }
        return {
            textContent: value
        };
    },

blurHandler: function blurHandler(event) {

this.props.onChange(event.target.value, 1);
    },

validateValue: function validateValue(value) {

var result = true;
        if (null == value || !('string' == typeof value || 'number' == typeof value)) {
            result = false;
        }
        return result;
    },

keyPressHandler: function keyPressHandler(quickchange, event) {

render: function render() {

var moduleName = this.props.moduleName,
            quickchange = !this.props.isAjax && 'testimonial' !== moduleName ? true : false;
        return React.createElement(AntTextArea, { placeholder: Immutable.Map.isMap(this.props.options) && this.props.options.get('placeholder'), rows: 8, value: this.state.textContent, onChange: this.keyPressHandler.bind(null, quickchange) });
    }
});
exports.default = TextArea;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 657 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery) {

var VirtualizedList = __webpack_require__(659),
    ButtonGroup = __webpack_require__(211).default,
    findDOMNode = ReactDOM.findDOMNode,
    RenderToBody = __webpack_require__(125);

var FontFamily = React.createClass({
    displayName: 'FontFamily',

dropDowTop: 0,
    getInitialState: function getInitialState() {

var fontValue = this.props.value.split(':'),
            selectedSource = fontValue[0] || 'google',
            selectedFont = fontValue[1];

return {
            showDropDown: false,
            selectedSource: selectedSource,
            searchText: '',
            selectedFont: selectedFont
        };
    },

changeHandler: function changeHandler(value, source) {
        this.setState({
            showDropDown: false,
            searchText: ''
        });
        this.props.changeHandler(source + ':' + value);
    },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        var fontValue = nextProps.value.split(':'),
            selectedSource = fontValue[0],
            selectedFont = fontValue[1];

this.setState({ selectedSource: selectedSource, selectedFont: selectedFont });
    },

render: function render() {
        var hasTypekit = window.typehub_font_options ? !jQuery.isEmptyObject(window.typehub_font_options.typekit) : false;
        var sourceOptions = jQuery.extend({}, {
            'google': 'Google',
            'standard': 'Standard',
            'custom': 'Custom',
            'schemes': 'Schemes'
        }, hasTypekit ? { 'typekit': 'Typekit' } : {});
        sourceOptions = { options: sourceOptions };
        var displayFontName = this.state.selectedFont;

if (this.state.selectedSource === 'schemes') {
            if (window.typehub_font_options.schemes[this.state.selectedFont]) {
                displayFontName = window.typehub_font_options.schemes[this.state.selectedFont].name;
            }
        }
        var dropDownTop = '',
            dropDownHeight = 300,
            node = findDOMNode(this);

if (node) {
            var nodePosition = node.getBoundingClientRect();

if (window.innerHeight < nodePosition.bottom + dropDownHeight) {
                dropDownTop = nodePosition.top - dropDownHeight + 'px';
            } else {
                dropDownTop = nodePosition.top + 35 + 'px';
            }
        }
        displayFontName = displayFontName || 'Select a Font';
        return React.createElement(
            'div',
            { className: 'be-pb-font-family' },
            React.createElement(
                'div',
                { onClick: function () {
                        this.setState({ showDropDown: !this.state.showDropDown });
                    }.bind(this), className: 'be-pb-font-family-input' },
                displayFontName,
                React.createElement(
                    'span',
                    { className: 'drop-down-arrow', style: { marginRight: 3 } },
                    React.createElement(
                        'svg',
                        { style: jQuery.extend({}, { transition: 'transform 200ms ease' }, this.state.showDropDown ? { transform: 'rotate( 180deg)' } : {}), viewBox: '64 64 896 896', 'class': '', 'data-icon': 'down', width: '1em', height: '1em', fill: 'currentColor', 'aria-hidden': 'true' },
                        React.createElement('path', { d: 'M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3.1-12.7-6.4-12.7z' })
                    )
                )
            ),
            this.state.showDropDown && React.createElement(
                'div',
                null,
                React.createElement(
                    RenderToBody,
                    null,
                    React.createElement(
                        'div',
                        { className: 'be-pb-font-family-dd', style: { top: dropDownTop, left: 40 } },
                        React.createElement(
                            'div',
                            { className: 'be-pb-ff-drop-down-top' },
                            React.createElement(
                                'div',
                                { className: 'be-editor-field button_group ' },
                                React.createElement(ButtonGroup, { options: sourceOptions, value: this.state.selectedSource, multiSelect: false, onChange: function (e) {
                                        this.setState({ selectedSource: e });
                                    }.bind(this) })
                            ),
                            React.createElement(
                                'div',
                                null,
                                React.createElement('input', { placeholder: 'Search', value: this.state.searchText, onChange: function (e) {
                                        this.setState({ searchText: e.target.value });
                                    }.bind(this), autoFocus: true })
                            )
                        ),
                        React.createElement(
                            'div',
                            null,
                            React.createElement(VirtualizedList, {
                                height: '195',
                                width: '360',
                                clickHandler: this.changeHandler,
                                clickedFont: this.props.value,
                                source: this.state.selectedSource,
                                searchText: this.state.searchText
                            })
                        )
                    )
                ),
                React.createElement('div', { className: 'be-pb-typography-overlay', onClick: function () {
                        this.setState({ showDropDown: false });
                    }.bind(this) })
            )
        );
    }
});

module.exports = FontFamily;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 658 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

var SelectComponent = __webpack_require__(93).default,
    FontFamily = __webpack_require__(657),
    loadFont = __webpack_require__(717),
    Number = __webpack_require__(150).default,
    findDOMNode = ReactDOM.findDOMNode,
    RenderToBody = __webpack_require__(125),
    shortId = __webpack_require__(116);

__webpack_require__(903);

var Typography = React.createClass({
    displayName: 'Typography',

getInitialState: function getInitialState() {
        var value = this.props.value || Immutable.Map();
        return {
            'font-family': value.get('font-family') || '',
            'font-variant': value.get('font-variant') || '',
            'text-transform': value.get('text-transform') || 'none',
            'font-size': value.get('font-size') || '',
            'line-height': value.get('line-height') || '',
            'letter-spacing': value.get('letter-spacing') || '',
            'isOpen': false
        };
    },

changeVariantsFormat: function changeVariantsFormat(variantsArray) {

if (variantsArray) {
            var variants = {};
            variantsArray.forEach(function (variant) {
                variants[variant.id] = variant.name;
            });

return variants;
        } else {
            return {};
        }
    },

getVariants: function getVariants(fontWithSource) {
        if (fontWithSource) {
            fontWithSource = fontWithSource.split(':');
            var source = fontWithSource[0],
                font = fontWithSource[1];

if (['google', 'custom', 'typekit'].indexOf(source) !== -1) {
                if (window.typehub_font_options.hasOwnProperty(source)) {
                    if (window.typehub_font_options[source].hasOwnProperty(font)) {
                        return window.typehub_font_options[source][font].variants;
                    }
                }
                return [{ id: '400', name: 'Normal 400' }];
            } else if (source === 'standard') {
                var variantList = [];
                if (font === 'System Font Stack') {
                    variantList = [{ id: '100', name: 'Ultra Light 100' }, { id: '100italic', name: 'Ultra Light 100 Italic' }, { id: '200', name: 'Light 200' }, { id: '200italic', name: 'Light 200 Italic' }, { id: '300', name: 'Book 300' }, { id: '300italic', name: 'Book 300 Italic' }, { id: '400', name: 'Normal 400' }, { id: '400italic', name: 'Normal 400 Italic' }, { id: '500', name: 'Medium 500' }, { id: '500italic', name: 'Medium 500 Italic' }, { id: '600', name: 'Semi-Bold 600' }, { id: '600italic', name: 'Semi-Bold 600 Italic' }, { id: '700', name: 'Bold 700' }, { id: '700italic', name: 'Bold 700 Italic' }, { id: '800', name: 'Extra-Bold 800' }, { id: '800italic', name: 'Extra-Bold 800 Italic' }, { id: '900', name: 'Ultra-Bold 900' }, { id: '900italic', name: 'Ultra-Bold 900 Italic' }];
                } else {
                    variantList = [{ id: '400', name: 'Normal 400' }, { id: '400italic', name: 'Normal 400 Italic' }, { id: '700', name: 'Bold 700' }, { id: '700italic', name: 'Bold 700 Italic' }];
                }

return variantList;
            } else if (source === 'schemes') {
                font = window.typehub_font_options.schemes[font].fontFamily;
                return this.getVariants(font);
            }
        } else {
            return [{ id: '400', name: 'Normal 400' }];
        }
    },
    changeHandler: function changeHandler(field, value) {

resetTypography: function resetTypography() {
        var newState = {
            'font-family': '',
            'font-variant': '',
            'text-transform': '',
            'font-size': '',
            'line-height': '',
            'letter-spacing': ''
        };

this.setState(newState, function () {
            var newValue = jQuery.extend({}, newState);
            delete newValue.isOpen;
            var valueAsMap = Immutable.fromJS(newValue);
            this.props.onChange(valueAsMap);
        });
    },
    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        var value = nextProps.value || Immutable.Map();

this.setState({
            'font-family': value.get('font-family') || '',
            'font-variant': value.get('font-variant') || '',
            'text-transform': value.get('text-transform') || '',
            'font-size': value.get('font-size') || '',
            'line-height': value.get('line-height') || '',
            'letter-spacing': value.get('letter-spacing') || ''
        }, function () {
            var tempVariants = this.getVariants(this.state['font-family']);
            if (!this.changeVariantsFormat(tempVariants).hasOwnProperty(this.state['font-variant'])) {
                this.setState({ 'font-variant': '' });
            }
        });
    },
    render: function render() {
        var _this = this;

var numberOptions = Immutable.fromJS({ unit: ['px', '%', 'em'] }),
            textTransforms = Immutable.fromJS({
            'none': 'None',
            'uppercase': 'Uppercase',
            'lowercase': 'Lowercase',
            'capitalize': 'Capitalize'
        });

var tempVariants = this.getVariants(this.state['font-family']);

var fontVariants = Immutable.fromJS(this.changeVariantsFormat(tempVariants));

var selectBoxOptions = {
            'text-transform': textTransforms,
            'font-variant': fontVariants
        };

if (node) {
            var nodePosition = node.getBoundingClientRect();

if (window.innerHeight < nodePosition.bottom + dropDownHeight) {
                dropDownTop = nodePosition.top - dropDownHeight - 40 + 'px';
                componentPostion = 'be-pb-typography-top';
            } else {
                dropDownTop = nodePosition.top + 60 + 'px';
                componentPostion = 'be-pb-typography-bottom';
            }
        }

return React.createElement(
            'div',
            { style: { display: 'flex', alignItems: 'center' } },
            React.createElement(
                'div',
                { className: 'be-pb-typography-icon', onClick: function onClick() {
                        return _this.setState({ isOpen: true });
                    } },
                React.createElement(
                    'svg',
                    { width: '24', height: '24', viewBox: '0 0 24 24' },
                    React.createElement('path', { fill: 'none', d: 'M0 0h24v24H0z' }),
                    React.createElement('path', { d: 'M2.5 4v3h5v12h3V7h5V4h-13zm19 5h-9v3h3v7h3v-7h3V9z' })
                )
            ),
            React.createElement(
                'div',
                { className: 'be-pb-typography-reset', onClick: this.resetTypography.bind(this), style: { lineHeight: 1, paddingLeft: 5, cursor: 'pointer', visibility: this.state.isOpen ? 'hidden' : 'visible' } },
                React.createElement(
                    'svg',
                    { width: '14', height: '14', viewBox: '0 0 24 24' },
                    React.createElement('path', { fill: 'none', d: 'M0 0h24v24H0V0z' }),
                    React.createElement('path', { fill: 'red', d: 'M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12 19 6.41z' })
                )
            ),
            React.createElement(
                'div',
                { className: 'be-pb-typography-values', onClick: function onClick() {
                        return _this.setState({ isOpen: true });
                    } },
                React.createElement(
                    'div',
                    { className: 'be-pb-typo-values-top' },
                    React.createElement(
                        'div',
                        { className: 'be-pb-typography-ff be-pb-typo-value-item' },
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-icon' },
                            React.createElement(
                                'svg',
                                { viewBox: '0 0 24 24' },
                                React.createElement('path', { fill: 'none', d: 'M0 0h24v24H0V0z' }),
                                React.createElement('path', { d: 'M9.17 15.5h5.64l1.14 3h2.09l-5.11-13h-1.86l-5.11 13h2.09l1.12-3zM12 7.98l2.07 5.52H9.93L12 7.98zM20 2H4c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 18H4V4h16v16z' })
                            )
                        ),
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-value' },
                            this.state['font-family'] ? this.state['font-family'].split(':')[1] : 'Inherit'
                        )
                    ),
                    React.createElement(
                        'div',
                        { className: 'be-pb-typography-fv be-pb-typo-value-item' },
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-icon' },
                            React.createElement(
                                'svg',
                                { viewBox: '0 0 24 24' },
                                React.createElement('path', { fill: 'none', d: 'M0 0h24v24H0V0z' }),
                                React.createElement('path', { d: 'M15.6 10.79c.97-.67 1.65-1.77 1.65-2.79 0-2.26-1.75-4-4-4H7v14h7.04c2.09 0 3.71-1.7 3.71-3.79 0-1.52-.86-2.82-2.15-3.42zM10 6.5h3c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5h-3v-3zm3.5 9H10v-3h3.5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5z' })
                            )
                        ),
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-value' },
                            this.state['font-variant'] ? this.state['font-variant'] : ''
                        )
                    )
                ),
                React.createElement(
                    'div',
                    { className: 'be-pb-typo-values-bottom' },
                    React.createElement(
                        'div',
                        { className: 'be-pb-typography-tt be-pb-typo-value-item' },
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-icon' },
                            React.createElement(
                                'svg',
                                { viewBox: '0 0 24 24' },
                                React.createElement('path', { fill: 'none', d: 'M0 0h24v24H0z' }),
                                React.createElement('path', { d: 'M2.5 4v3h5v12h3V7h5V4h-13zm19 5h-9v3h3v7h3v-7h3V9z' })
                            )
                        ),
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-value' },
                            React.createElement(
                                'span',
                                { style: { textTransform: this.state['text-transform'] ? this.state['text-transform'] : 'None' } },
                                'aa'
                            )
                        )
                    ),
                    React.createElement(
                        'div',
                        { className: 'be-pb-typography-fs be-pb-typo-value-item' },
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-icon' },
                            React.createElement(
                                'svg',
                                { viewBox: '0 0 20 20' },
                                React.createElement('path', { d: 'M3.23,9.54.26,13H2.4v6.89H4.05V13H6.2Z' }),
                                React.createElement('path', { d: 'M2.46.55H19.66l.14,6.27H18.12L18,5a3,3,0,0,0-.9-2.17,3.91,3.91,0,0,0-2.49-.64,2.43,2.43,0,0,0-1.69.44,2.67,2.67,0,0,0-.45,1.84l0,11.43a2.59,2.59,0,0,0,.45,1.8,2.6,2.6,0,0,0,1.77.44h1.22v1.66H6.25V18.17H7.68a2.15,2.15,0,0,0,1.58-.46,2.62,2.62,0,0,0,.45-1.78V4.45a2.55,2.55,0,0,0-.46-1.78,2.44,2.44,0,0,0-1.71-.45A3.9,3.9,0,0,0,5,2.85,3,3,0,0,0,4.14,5L4,6.81H2.3Z' })
                            )
                        ),
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-value' },
                            this.state['font-size'] ? this.state['font-size'] : '-'
                        )
                    ),
                    React.createElement(
                        'div',
                        { className: 'be-pb-typography-ls be-pb-typo-value-item' },
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-icon' },
                            React.createElement(
                                'svg',
                                { viewBox: '0 0 20 20' },
                                React.createElement('polygon', { points: '16,6 14.6,7.4 16.2,9 3.8,9 5.4,7.4 4,6 0,10 4,14 5.4,12.6 3.8,11 16.2,11 14.6,12.6 16,14 20,10' })
                            )
                        ),
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-value' },
                            this.state['letter-spacing'] ? this.state['letter-spacing'] : '-'
                        )
                    ),
                    React.createElement(
                        'div',
                        { className: 'be-pb-typography-lh be-pb-typo-value-item' },
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-icon' },
                            React.createElement(
                                'svg',
                                { viewBox: '0 0 128 128' },
                                React.createElement(
                                    'g',
                                    null,
                                    React.createElement('polygon', { id: 'XMLID_41_', points: '64,128 26.359,81.46 33.574,75.623 59.359,107.502 59.359,20.498 33.574,52.377 26.359,46.54 64,0 101.641,46.54 94.426,52.377 68.641,20.498 68.641,107.502 94.426,75.623 101.641,81.46 \t' })
                                )
                            )
                        ),
                        React.createElement(
                            'div',
                            { className: 'be-pb-typo-value' },
                            this.state['line-height'] ? this.state['line-height'] : '-'
                        )
                    )
                )
            ),
            this.state.isOpen && [React.createElement(
                RenderToBody,
                null,
                React.createElement(
                    'div',
                    { className: "be-pb-typography-component " + componentPostion, style: { top: dropDownTop, left: 20 } },
                    React.createElement(
                        'div',
                        { className: 'be-pb-typography-left' },
                        selectFieldComponents
                    ),
                    React.createElement(
                        'div',
                        { className: 'be-pb-typography-right' },
                        numberFieldComponents
                    )
                )
            ), React.createElement('div', { className: 'be-pb-typography-overlay', onClick: function () {
                    this.setState({ isOpen: false });
                }.bind(this) })]
        );
    }
});

module.exports = Typography;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 659 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var List = __webpack_require__(314).List;

var VirtualizedList = React.createClass({
    displayName: 'VirtualizedList',

activeFontSchemes: function () {
        if (window.typehub_font_options && window.typehub_font_options.schemes) {
            return Object.keys(window.typehub_font_options.schemes).filter(function (scheme) {
                return window.typehub_font_options.schemes[scheme].active;
            });
        }
        return [];
    }(),
    listRenderFn: function listRenderFn(dataObject) {
        var classes = 'font-list-item';
        if (this.props.clickedFont && this.props.clickedFont.split(':')[1] === this.filteredArray[dataObject.index].display || this.props.clickedFont.split(':')[1] === this.filteredArray[dataObject.index].value) {
            classes = 'font-list-item selected ';
        }

return React.createElement(
            'div',
            {
                key: dataObject.key,
                style: dataObject.style,
                onClick: this.props.clickHandler.bind(null, this.filteredArray[dataObject.index].value, this.props.source),
                className: classes
            },
            this.filteredArray[dataObject.index].display
        );
    },

render: function render() {
        var props = this.props;
        var itemsArray = [];
        if (window.typehub_font_options && window.typehub_font_options.hasOwnProperty(props.source)) {
            if (props.source === 'schemes') {
                itemsArray = this.activeFontSchemes.map(function (scheme) {
                    return { display: window.typehub_font_options.schemes[scheme].name + ' - ' + window.typehub_font_options.schemes[scheme].fontFamily.split(':')[1], value: scheme };
                });
            } else {
                itemsArray = Object.keys(window.typehub_font_options[props.source]).map(function (item) {
                    return { display: item, value: item };
                });
            }
        }
        if (props.searchText) {
            this.filteredArray = itemsArray.filter(function (item) {
                return item.display.toLowerCase().startsWith(props.searchText.toLowerCase());
            });
        } else {
            this.filteredArray = itemsArray;
        }

var scrollIndex = 0,
            selectedFont = this.props.clickedFont.split(':')[1];

this.filteredArray.forEach(function (item, index) {
            if (item.value === selectedFont) {
                scrollIndex = index;
            }
        }.bind(this));

return React.createElement(List, {
            width: props.width,
            height: props.height,
            scrollToIndex: scrollIndex + 2,
            rowCount: this.filteredArray.length,
            rowHeight: 40,
            rowRenderer: this.listRenderFn
        });
    }
});

module.exports = VirtualizedList;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 660 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable, React) {

var coreModuleEdit = __webpack_require__(2).coreModuleEdit,
    editModule = __webpack_require__(2).editModule,
    store = __webpack_require__(11),
    BeField = __webpack_require__(661).default;
//getEditorComponent = require( '../../../helpers/editor/getEditorComponent' );

module.exports.getEditorFields = function getEditorFields(fieldValue, fieldStateMap, serializedPath, moduleName, moduleOptions, targetDisplay, moduleId, completeAtts, filterText) {

var fieldType = fieldStateMap.get('type'),
      fieldKey = fieldStateMap.get('att_name'),
      isResponsive = fieldStateMap.get('responsive'),
      fieldAttname = fieldStateMap.get('att_name'),
      isAjax = 'core' !== moduleOptions.getIn([moduleName, 'type']) && !moduleOptions.getIn([moduleName, 'is_built_in']),
      attKey = moduleId + fieldAttname,
      argAttName = '';

//To Roll Back Responsiveness on any Att
  if ((!isResponsive || isResponsive == false) && Immutable.Map.isMap(fieldValue) && fieldType != 'color') {
    fieldValue = fieldValue.get('d');
  }

var changeHandler = function changeHandler(value, shouldBeAdded) {
    var argAttValue = value;
    if ('string' == typeof value || 'number' == typeof value || fieldType == 'color' || fieldType == 'typography') {
      argAttName = fieldKey, argAttValue = value;
    } else {
      argAttName = value.targetAtt;
      argAttValue = value.value;
    }

store.dispatch(
    // editModule( serializedPath, moduleName, 'string' == typeof value ? fieldKey : value.targetAtt,  'string' == typeof value ? value : value.value, fieldStateMap, shouldBeAdded )
    editModule(serializedPath, moduleName, argAttName, argAttValue, fieldStateMap, shouldBeAdded));
  };
  return React.createElement(BeField, { moduleName: moduleName,
    moduleOptions: moduleOptions,
    isAjax: isAjax,
    targetDisplay: targetDisplay,
    key: attKey,
    value: fieldValue,
    onChange: changeHandler,
    attMap: fieldStateMap,
    filterText: filterText
  });
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0)))

/***/ }),
/* 661 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _tooltip = __webpack_require__(58);

var _tooltip2 = _interopRequireDefault(_tooltip);

__webpack_require__(59);

var _EditorConstants = __webpack_require__(95);

var _EditorHelpers = __webpack_require__(26);

var _number = __webpack_require__(150);

var _number2 = _interopRequireDefault(_number);

var _text = __webpack_require__(356);

var _text2 = _interopRequireDefault(_text);

var _select = __webpack_require__(93);

var _select2 = _interopRequireDefault(_select);

var _numberGroup = __webpack_require__(213);

var _numberGroup2 = _interopRequireDefault(_numberGroup);

var _selectImage = __webpack_require__(650);

var _selectImage2 = _interopRequireDefault(_selectImage);

var _buttonGroup = __webpack_require__(211);

var _buttonGroup2 = _interopRequireDefault(_buttonGroup);

var _switch = __webpack_require__(654);

var _switch2 = _interopRequireDefault(_switch);

var _iconPicker = __webpack_require__(646);

var _iconPicker2 = _interopRequireDefault(_iconPicker);

var _screenVisibility = __webpack_require__(649);

var _screenVisibility2 = _interopRequireDefault(_screenVisibility);

var _beSlider = __webpack_require__(641);

var _beSlider2 = _interopRequireDefault(_beSlider);

var _link = __webpack_require__(663);

var _link2 = _interopRequireDefault(_link);

var _label = __webpack_require__(662);

var _label2 = _interopRequireDefault(_label);

var _responsiveToggle = __webpack_require__(664);

var _responsiveToggle2 = _interopRequireDefault(_responsiveToggle);

var _boxShadow = __webpack_require__(642);

var _boxShadow2 = _interopRequireDefault(_boxShadow);

var _dropShadow = __webpack_require__(643);

var _dropShadow2 = _interopRequireDefault(_dropShadow);

var _textarea = __webpack_require__(656);

var _textarea2 = _interopRequireDefault(_textarea);

__webpack_require__(904);

var _svgIconPicker = __webpack_require__(653);

var _svgIconPicker2 = _interopRequireDefault(_svgIconPicker);

var _groupedCheckBox = __webpack_require__(645);

var _groupedCheckBox2 = _interopRequireDefault(_groupedCheckBox);

var _beFieldBackwardComp = __webpack_require__(692);

var _beFieldBackwardComp2 = _interopRequireDefault(_beFieldBackwardComp);

var _emptyCheck = __webpack_require__(5);

var _emptyCheck2 = _interopRequireDefault(_emptyCheck);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var smartSearch = __webpack_require__(158),
    searchTextHighlight = __webpack_require__(376);

var tatsuEditor = __webpack_require__(655),
    GradientColorPicker = __webpack_require__(212),
    singleImagePicker = __webpack_require__(652),
    multiImagePicker = __webpack_require__(647),
    typography = __webpack_require__(658);

//import constants from 'EditorConstants';
var Components = {
    color: GradientColorPicker,
    number: _number2.default,
    text: _text2.default,
    text_area: _textarea2.default,
    select: _select2.default,
    input_group: _numberGroup2.default,
    select_image: _selectImage2.default,
    button_group: _buttonGroup2.default,
    switch: _switch2.default,
    slider: _beSlider2.default,
    negative_number: _numberGroup2.default,
    icon_picker: _iconPicker2.default,
    screen_visibility: _screenVisibility2.default,
    tinymce: tatsuEditor,
    single_image_picker: singleImagePicker,
    multi_image_picker: multiImagePicker,
    input_box_shadow: _boxShadow2.default,
    input_drop_shadow: _dropShadow2.default,
    svg_icon_picker: _svgIconPicker2.default,
    grouped_checkbox: _groupedCheckBox2.default,
    typography: typography
};

var BeField = function (_React$Component) {
    _inherits(BeField, _React$Component);

function BeField(props) {
        _classCallCheck(this, BeField);

var _this = _possibleConstructorReturn(this, (BeField.__proto__ || Object.getPrototypeOf(BeField)).call(this, props));

if ('input_group' == props.attMap.get('type')) {
            _this.state = {
                link: false
            };
        }
        _this.clickHandler = _this.clickHandler.bind(_this);
        return _this;
    }

_createClass(BeField, [{
        key: 'clickHandler',
        value: function clickHandler(e) {
            this.setState({
                link: !this.state.link
            });
        }
    }, {
        key: 'render',
        value: function render() {
            var attMap = this.props.attMap,
                moduleName = this.props.moduleName,
                moduleOptions = this.props.moduleOptions,
                attType = attMap.get('type'),
                inlineFieldsFixedWidth = ['select', 'text', 'screen_visibility'],
                isResponsive = attMap.get('responsive'),
                DynamicComponent = Components[attType],
                options = (0, _beFieldBackwardComp2.default)(attMap),
                tooltipText = attMap.get('tooltip'),
                value = this.props.value;

var isInline = attMap.get('is_inline'),
                attLabel = attMap.get('label');

if (isInline == null) {
                isInline = _EditorConstants.inlineFields.indexOf(attType) > -1;
            }

if (this.props.filterText && typeof attLabel === 'string' && smartSearch(attLabel, this.props.filterText)) {
                attLabel = searchTextHighlight(this.props.filterText, attLabel);
            }

return React.createElement(
                'div',
                { className: (0, _EditorHelpers.getClassNames)('be-field-wrap', 'be-field-wrap-' + attType, isInline ? 'be-field-wrap-inline' : 'be-field-wrap-block', this.props.className, isInline && -1 < inlineFieldsFixedWidth.indexOf(attType) ? 'be-field-wrap-inline-fixed-width' : null) },
                React.createElement(_label2.default, { text: attLabel }),
                isResponsive && React.createElement(_responsiveToggle2.default, { curDisplay: this.props.targetDisplay }),
                'input_group' == attType && React.createElement(_link2.default, { onClick: this.clickHandler, active: this.state.link }),
                !(0, _emptyCheck2.default)(tooltipText) && React.createElement(
                    _tooltip2.default,
                    { mouseEnterDelay: 0.5, title: tooltipText },
                    React.createElement(
                        'div',
                        { className: 'tatsu-tooltip' },
                        React.createElement(
                            'svg',
                            { className: 'tatsu-svg-icon' },
                            React.createElement('use', { xlinkHref: tatsuConfig.svgs + '#tooltip' })
                        )
                    )
                ),
                React.createElement(
                    'div',
                    { className: 'be-field' },
                    'undefined' != typeof DynamicComponent && React.createElement(DynamicComponent, {
                        moduleName: moduleName,
                        moduleOptions: moduleOptions,
                        isAjax: this.props.isAjax || false,
                        onChange: this.props.onChange,
                        link: 'input_group' == attType ? this.state.link : null,
                        value: value,
                        options: options
                    })
                )
            );
        }
    }]);

return BeField;
}(React.Component);

exports.default = BeField;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 662 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

exports.default = function (props) {
    return React.createElement(
        'span',
        { className: (props.className || '') + " be-field-label" },
        props.text
    );
};

__webpack_require__(905);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 663 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

exports.default = function (props) {
    return React.createElement(
        "div",
        { onClick: props.onClick, className: (props.className || '') + " be-field-link" + (props.active ? " active" : "") },
        props.active ? React.createElement(
            "svg",
            { xmlns: "http://www.w3.org/2000/svg", xmlnsXlink: "http://www.w3.org/1999/xlink", version: "1.1", x: "0px", y: "0px", viewBox: "0 0 100 100", enableBackground: "new 0 0 100 100", xmlSpace: "preserve" },
            React.createElement(
                "g",
                null,
                React.createElement(
                    "g",
                    null,
                    React.createElement(
                        "g",
                        null,
                        React.createElement("path", { d: "M51.682,35.977l17.649-17.044c1.173-1.132,3.048-1.102,4.181,0.072l9.281,9.611     c1.136,1.175,1.101,3.05-0.072,4.183L65.071,49.842c-1.097,1.06-2.806,1.101-3.952,0.142l-5.682,5.487     c4.181,4.089,10.879,4.13,15.111,0.043l17.65-17.044c4.307-4.159,4.43-11.023,0.268-15.333l-9.281-9.611     C75.024,9.218,68.159,9.1,63.853,13.259L46.203,30.303c-3.809,3.677-4.348,9.468-1.541,13.74l6.119-5.91     C50.771,37.347,51.073,36.563,51.682,35.977z" })
                    ),
                    React.createElement(
                        "g",
                        null,
                        React.createElement("path", { d: "M36.143,88.74l17.648-17.043c4.234-4.089,4.426-10.783,0.484-15.104l-5.682,5.486     c0.919,1.178,0.818,2.885-0.28,3.945L30.664,83.068c-1.172,1.131-3.047,1.102-4.183-0.073L17.2,73.384     c-1.134-1.174-1.098-3.05,0.074-4.181l17.649-17.044c0.607-0.587,1.402-0.864,2.188-0.825l6.119-5.91     c-4.173-2.953-9.976-2.619-13.786,1.062L11.796,63.529c-4.308,4.159-4.429,11.024-0.269,15.332l9.281,9.611     C24.971,92.783,31.835,92.9,36.143,88.74z" })
                    ),
                    React.createElement(
                        "g",
                        null,
                        React.createElement("path", { d: "M62.639,37.6c-1.449-1.5-3.938-1.45-5.559,0.115L36.477,57.612c-1.62,1.563-1.76,4.054-0.311,5.554     c1.447,1.5,3.94,1.447,5.561-0.117L62.33,43.151C63.951,41.586,64.088,39.1,62.639,37.6z" })
                    )
                )
            )
        ) : React.createElement(
            "svg",
            { xmlns: "http://www.w3.org/2000/svg", xmlnsXlink: "http://www.w3.org/1999/xlink", version: "1.1", x: "0px", y: "0px", viewBox: "0 0 100 100", xmlSpace: "preserve" },
            React.createElement(
                "g",
                null,
                React.createElement("path", { d: "M31.9,79.6c-1.2,1.2-3.1,1.2-4.3,0l-7.1-7.1c-1.2-1.2-1.2-3.1,0-4.3l21.3-21.3c-5-2.4-11.2-1.6-15.3,2.6L14.5,61.3   c-5.2,5.2-5.2,13.7,0,18.9l5.3,5.3c5.2,5.2,13.7,5.2,18.9,0l11.9-11.9c4.1-4.1,5-10.3,2.6-15.3L31.9,79.6z" }),
                React.createElement("path", { d: "M85.5,19.8l-5.3-5.3c-5.2-5.2-13.7-5.2-18.9,0L49.4,26.4c-4.1,4.1-5,10.3-2.6,15.3l21.3-21.3c1.2-1.2,3.1-1.2,4.3,0   l7.1,7.1c1.2,1.2,1.2,3.1,0,4.3L58.3,53.1c5,2.4,11.2,1.6,15.3-2.6l11.9-11.9C90.8,33.4,90.8,25,85.5,19.8z" }),
                React.createElement("path", { d: "M29.9,33.8c0.5,0.5,1.2,0.8,1.9,0.8s1.4-0.3,1.9-0.8c1.1-1.1,1.1-2.8,0-3.8l-9.1-9.1c-1.1-1.1-2.8-1.1-3.8,0   c-1.1,1.1-1.1,2.8,0,3.8L29.9,33.8z" }),
                React.createElement("path", { d: "M31.2,36.6l-8.3-0.1c0,0,0,0,0,0c-1.5,0-2.7,1.2-2.7,2.7c0,1.5,1.2,2.7,2.7,2.7l8.3,0.1c0,0,0,0,0,0c1.5,0,2.7-1.2,2.7-2.7   C33.9,37.8,32.7,36.6,31.2,36.6z" }),
                React.createElement("path", { d: "M39.3,33.9C39.3,33.9,39.3,33.9,39.3,33.9c1.5,0,2.7-1.2,2.7-2.7l-0.1-8.3c0-1.5-1.2-2.7-2.7-2.7c0,0,0,0,0,0   c-1.5,0-2.7,1.2-2.7,2.7l0.1,8.3C36.6,32.7,37.8,33.9,39.3,33.9z" }),
                React.createElement("path", { d: "M70.1,66.2c-1.1-1.1-2.8-1.1-3.8,0c-1.1,1.1-1.1,2.8,0,3.8l9.1,9.1c0.5,0.5,1.2,0.8,1.9,0.8s1.4-0.3,1.9-0.8   c1.1-1.1,1.1-2.8,0-3.8L70.1,66.2z" }),
                React.createElement("path", { d: "M60.7,66.1c-1.5,0-2.7,1.2-2.7,2.7v8.3c0,1.5,1.2,2.7,2.7,2.7s2.7-1.2,2.7-2.7v-8.3C63.4,67.3,62.2,66.1,60.7,66.1z" }),
                React.createElement("path", { d: "M68.8,63.4h8.3c1.5,0,2.7-1.2,2.7-2.7S78.6,58,77.1,58h-8.3c-1.5,0-2.7,1.2-2.7,2.7S67.3,63.4,68.8,63.4z" })
            )
        )
    );
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 664 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _select = __webpack_require__(65);

var _select2 = _interopRequireDefault(_select);

__webpack_require__(66);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var store = __webpack_require__(11),
    changeTargetDisplay = __webpack_require__(2).changeTargetDisplay;

var Option = _select2.default.Option;

var ResponsiveToggle = function (_React$Component) {
    _inherits(ResponsiveToggle, _React$Component);

function ResponsiveToggle() {
        _classCallCheck(this, ResponsiveToggle);

return _possibleConstructorReturn(this, (ResponsiveToggle.__proto__ || Object.getPrototypeOf(ResponsiveToggle)).apply(this, arguments));
    }

_createClass(ResponsiveToggle, [{
        key: 'changeDisplay',
        value: function changeDisplay(target, event) {
            store.dispatch(changeTargetDisplay(target));
        }
    }, {
        key: 'getTargetDisplayIcon',
        value: function getTargetDisplayIcon(display) {
            switch (display) {
                case 'desktop':
                    return React.createElement(
                        'div',
                        { className: 'tatsu-trigger-desktop tatsu-trigger-icon' },
                        React.createElement(
                            'svg',
                            { role: 'img', className: 'tatsu-svg-icon be-pb-desktop-icon', viewBox: '0 0 20 20' },
                            React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-desktop' })
                        )
                    );
                case 'laptop':
                    return React.createElement(
                        'div',
                        { className: 'tatsu-trigger-laptop tatsu-trigger-icon' },
                        React.createElement(
                            'svg',
                            { role: 'img', className: 'tatsu-svg-icon be-pb-laptop-icon', viewBox: '0 0 20 20' },
                            React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-laptop' })
                        )
                    );
                case 'tablet':
                    return React.createElement(
                        'div',
                        { className: 'tatsu-trigger-tablet tatsu-trigger-icon' },
                        React.createElement(
                            'svg',
                            { role: 'img', className: 'tatsu-svg-icon be-pb-tablet-icon', viewBox: '0 0 20 20' },
                            React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-tablet' })
                        )
                    );
                case 'mobile':
                    return React.createElement(
                        'div',
                        { className: 'tatsu-trigger-mobile tatsu-trigger-icon' },
                        React.createElement(
                            'svg',
                            { role: 'img', className: 'tatsu-svg-icon be-pb-mobile-icon', viewBox: '0 0 20 20' },
                            React.createElement('use', { xlinkHref: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-mobile' })
                        )
                    );
            }
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

return React.createElement(
                _select2.default,
                { dropdownMatchSelectWidth: false, className: 'be-field-responsive-toggle', dropdownClassName: 'be-field-responsive-toggle-dropdown', showArrow: false, value: this.props.curDisplay, onChange: this.changeDisplay, getPopupContainer: function getPopupContainer(triggerNode) {
                        return triggerNode.parentNode;
                    } },
                ['desktop', 'laptop', 'tablet', 'mobile'].map(function (curDisplay) {
                    return React.createElement(
                        Option,
                        { key: curDisplay, value: curDisplay },
                        _this2.getTargetDisplayIcon(curDisplay)
                    );
                })
            );
        }
    }]);

return ResponsiveToggle;
}(React.Component);

exports.default = ResponsiveToggle;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 665 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var Immutable = __webpack_require__(3),
    mapChecker = __webpack_require__(16).mapChecker,
    orderedMapChecker = __webpack_require__(16).orderedMapChecker,
    listChecker = __webpack_require__(16).listChecker,
    smartSearch = __webpack_require__(158),
    searchTextHighlight = __webpack_require__(376),
    checkConditionalAtts = __webpack_require__(365),
    Tabs = __webpack_require__(361).default,
    Collapse = __webpack_require__(1134).default,
    Panel = Collapse.Panel,
    TabPane = Tabs.Panel,
    findDOMNode = __webpack_require__(7).findDOMNode,
    resetSelection = __webpack_require__(2).resetSelection,
    setSelection = __webpack_require__(2).setSelection,
    editorFields = __webpack_require__(660),
    LayoutTabContent = __webpack_require__(668).default,
    deleteModule = __webpack_require__(2).deleteModule,
    duplicateModule = __webpack_require__(2).duplicate,
    store = __webpack_require__(11);
__webpack_require__(906);
__webpack_require__(1455);

var ModuleEditor = React.createClass({
  displayName: 'ModuleEditor',

propTypes: {
    targetElement: mapChecker,
    modulePath: listChecker,
    targetDisplay: React.PropTypes.string,
    pageContent: mapChecker,
    moduleOptions: mapChecker,
    moduleId: React.PropTypes.string.isRequired,
    isMultiSelected: React.PropTypes.bool.isRequired,
    enableGrouping: React.PropTypes.bool.isRequired,
    attsToList: orderedMapChecker,
    attsFromModuleOptions: listChecker
  },

getTabIcon: function getTabIcon(options) {
    if (options.has('icon')) {
      return options.get('icon');
    } else {
      //if( -1 < [ 'Content', 'Style', 'Advanced', 'Layout' ].indexOf( options.get( 'title' ) ) ) {

var returnLayoutIcon = false;

if (this.props.builderMode === 'header_builder') {
        returnLayoutIcon = 'multi' == this.props.moduleOptions.getIn([this.props.moduleName, 'type']) && [3, 5].indexOf(this.props.modulePath.size) > -1 || this.props.moduleName === 'tatsu_hamburger_menu';
      } else {
        if ('multi' == this.props.moduleOptions.getIn([this.props.moduleName, 'type']) && [4, 6].indexOf(this.props.modulePath.size) > -1) {
          var childModuleName = this.props.moduleOptions.getIn([this.props.moduleName, 'child_module']),
              childModuleTitle = this.props.moduleOptions.getIn([childModuleName, 'title']);
          if (options.get('title') === childModuleTitle + 's') {
            returnLayoutIcon = true;
          }
        }
      }

switch (options.get('title')) {
        case 'Content':
          return React.createElement(
            'svg',
            { width: '21px', height: '22px', viewBox: '0 0 21 22', version: '1.1', xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink' },
            React.createElement(
              'g',
              { id: 'Desktop-HD', strokeWidth: '1', fillRule: 'evenodd', transform: 'translate(-43.000000, -86.000000)' },
              React.createElement(
                'g',
                { id: 'Field-Tabs', transform: 'translate(0.000000, 73.000000)', fillRule: 'nonzero' },
                React.createElement(
                  'g',
                  { id: 'Group-14', transform: 'translate(31.000000, 13.000000)' },
                  React.createElement(
                    'g',
                    { id: 'noun_236365', transform: 'translate(11.000000, 0.000000)' },
                    React.createElement('path', { d: 'M13.2857143,1.71428571 L13.2857143,20.5714286 L11.1428571,25.7142857 L9,20.5714286 L9,-0.857142857 L9.85714286,-1.71428571 L12.4285714,-1.71428571 L13.2857143,-0.857142857 L13.2857143,0.857142857 L15,0.857142857 L15,7.71428571 L14.1428571,7.71428571 L14.1428571,1.71428571 L13.2857143,1.71428571 Z M9.85714286,0.857142857 L9.85714286,-0.514286057 L10.1999949,-0.857142857 L12.0857194,-0.857142857 L12.4285714,-0.514286057 L12.4285714,0.857142857 L9.85714286,0.857142857 Z M9.85714286,1.71428571 L9.85714286,19.7142857 L12.4285714,19.7142857 L12.4285714,1.71428571 L9.85714286,1.71428571 Z M11.142852,23.5019006 L12.351432,20.5714286 L9.93428229,20.5714286 L11.142852,23.5019006 Z', id: 'Shape', transform: 'translate(12.000000, 12.000000) rotate(45.000000) translate(-12.000000, -12.000000) ' })
                  )
                )
              )
            )
          );
        case 'Style':
          return React.createElement(
            'svg',
            { width: '16px', height: '24px', viewBox: '0 0 16 24', version: '1.1', xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink' },
            React.createElement(
              'g',
              { id: 'Desktop-HD', strokeWidth: '1', fillRule: 'evenodd', transform: 'translate(-142.000000, -84.000000)' },
              React.createElement(
                'g',
                { id: 'Field-Tabs', transform: 'translate(0.000000, 73.000000)', fillRule: 'nonzero' },
                React.createElement(
                  'g',
                  { id: 'Group-18', transform: 'translate(108.000000, 0.000000)' },
                  React.createElement(
                    'g',
                    { id: 'Group-14', transform: 'translate(27.000000, 11.000000)' },
                    React.createElement(
                      'g',
                      { id: 'noun_384100', transform: 'translate(7.000000, 0.000000)' },
                      React.createElement('path', { d: 'M8,22.1329392 L8,2.62882165 C8.00349579,2.62508752 8.00752941,2.62081995 8.01102519,2.61708584 C10.0977479,4.81968416 14.1176471,9.8980896 14.1176471,16.3317145 C14.1176471,19.4763783 11.3161681,22.1329392 8,22.1329392 M8,0 C8,0 0,6.82250699 0,16.3317145 C0,20.5667419 3.73028572,24 8,24 C12.2697143,24 16,20.5667419 16,16.3317145 C16,6.66807437 8,0 8,0', id: 'Shape' })
                    )
                  )
                )
              )
            )
          );
        case 'Advanced':
          return React.createElement(
            'svg',
            { width: '12px', height: '23px', viewBox: '0 0 12 23', version: '1.1', xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink' },
            React.createElement(
              'g',
              { id: 'Desktop-HD', strokeWidth: '1', fillRule: 'evenodd', transform: 'translate(-242.000000, -86.000000)' },
              React.createElement(
                'g',
                { id: 'Field-Tabs', transform: 'translate(0.000000, 73.000000)', fillRule: 'nonzero' },
                React.createElement(
                  'g',
                  { id: 'Group-14', transform: 'translate(220.000000, 13.000000)' },
                  React.createElement(
                    'g',
                    { id: 'noun_1185113', transform: 'translate(22.000000, 0.000000)' },
                    React.createElement('path', { d: 'M6,0 L6,23 L12,23 L12,0 L6,0 Z M11.0886076,22.024852 L6.91139241,22.024852 L6.91139241,20.8869214 L8.20253165,20.8869214 L8.20253165,20.2367196 L6.91139241,20.2367196 L6.91139241,19.098789 L8.20253165,19.098789 L8.20253165,18.4485872 L6.91139241,18.4485872 L6.91139241,17.3106566 L9.49367089,17.3106566 L9.49367089,16.6601453 L6.91139241,16.6601453 L6.91139241,15.5222147 L8.20253165,15.5222147 L8.20253165,14.8720129 L6.91139241,14.8720129 L6.91139241,13.7340823 L8.20253165,13.7340823 L8.20253165,13.0838805 L6.91139241,13.0838805 L6.91139241,11.9459499 L9.49367089,11.9459499 L9.49367089,11.2957481 L6.91139241,11.2957481 L6.91139241,10.1578175 L8.20253165,10.1578175 L8.20253165,9.50761572 L6.91139241,9.50761572 L6.91139241,8.36968515 L8.20253165,8.36968515 L8.20253165,7.71948332 L6.91139241,7.71948332 L6.91139241,6.58155274 L9.49367089,6.58155274 L9.49367089,5.93135091 L6.91139241,5.93135091 L6.91139241,4.79342034 L8.20253165,4.79342034 L8.20253165,4.14321851 L6.91139241,4.14321851 L6.91139241,3.00528794 L8.20253165,3.00528794 L8.20253165,2.35508611 L6.91139241,2.35508611 L6.91139241,0.973600646 L11.0886076,0.973600646 L11.0886076,22.024852 Z', id: 'Shape' }),
                    React.createElement('path', { d: 'M2.5,0 C1.2546875,0 0.2221875,0.90737352 0.03375,2.08893972 L0,2.08893972 L0,2.47578041 L0,3.0114774 L0,18.3362487 L0.05,18.3362487 L2.5003125,23 L4.9503125,18.3362487 L5,18.3362487 L5,3.20551668 L5,2.47578041 L5,2.08893972 L4.96625,2.08893972 C4.7778125,0.90737352 3.7453125,0 2.5,0 Z M2.5,0.928417653 C3.2259375,0.928417653 3.8321875,1.42357374 4.0065625,2.08893972 L0.993125,2.08893972 C1.1678125,1.42326426 1.7740625,0.928417653 2.5,0.928417653 Z M0.9375,3.01735737 L2.1875,3.01735737 L2.1875,17.407831 L0.9375,17.407831 L0.9375,3.01735737 Z M2.5,20.9884284 L1.594375,19.2646663 L3.405625,19.2646663 L2.5,20.9884284 Z M4.0625,17.407831 L2.8125,17.407831 L2.8125,3.01735737 L4.0625,3.01735737 L4.0625,17.407831 Z', id: 'Shape' })
                  )
                )
              )
            )
          );

default:
          if (returnLayoutIcon || options.get('title') === 'Layout') {
            return React.createElement(
              'svg',
              { width: '16', height: '24', viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg' },
              React.createElement('path', { fillRule: 'evenodd', clipRule: 'evenodd', d: 'M6.08671 8.81179H1.68082C1.07198 8.81179 0.579346 9.30611 0.579346 9.91411V14.32C0.579346 14.928 1.07198 15.4215 1.68082 15.4215H6.08671C6.69556 15.4215 7.18819 14.928 7.18819 14.32V9.91411C7.18819 9.30611 6.69471 8.81179 6.08671 8.81179ZM6.08671 13.7693C6.08671 14.0733 5.83998 14.32 5.53598 14.32H2.23071C1.92671 14.32 1.67998 14.0733 1.67998 13.7693V10.4648C1.67998 10.1608 1.92587 9.91411 2.23071 9.91411H5.53514C5.83914 9.91411 6.08587 10.1608 6.08587 10.4648V13.7693H6.08671ZM14.8985 8.81179H10.4926C9.88377 8.81179 9.39114 9.30611 9.39114 9.91411V14.32C9.39114 14.928 9.88377 15.4215 10.4926 15.4215H14.8985C15.5065 15.4215 16 14.928 16 14.32V9.91411C16 9.30611 15.5065 8.81179 14.8985 8.81179ZM14.8985 13.7693C14.8985 14.0733 14.6518 14.32 14.3478 14.32H11.0433C10.7393 14.32 10.4926 14.0733 10.4926 13.7693V10.4648C10.4926 10.1608 10.7393 9.91411 11.0433 9.91411H14.3478C14.6518 9.91411 14.8985 10.1608 14.8985 10.4648V13.7693ZM6.08671 0H1.68082C1.07198 0 0.579346 0.492632 0.579346 1.10147V5.50737C0.579346 6.11621 1.07198 6.60884 1.68082 6.60884H6.08671C6.69556 6.60884 7.18819 6.11621 7.18819 5.50737V1.10147C7.18819 0.492632 6.69471 0 6.08671 0ZM6.08671 4.95663C6.08671 5.26063 5.83998 5.50737 5.53598 5.50737H2.23071C1.92671 5.50737 1.67998 5.26147 1.67998 4.95663V1.65221C1.67998 1.34821 1.92587 1.10147 2.23071 1.10147H5.53514C5.83914 1.10147 6.08587 1.34737 6.08587 1.65221V4.95663H6.08671ZM14.8985 0H10.4926C9.88377 0 9.39114 0.492632 9.39114 1.10147V5.50737C9.39114 6.11621 9.88377 6.60884 10.4926 6.60884H14.8985C15.5065 6.60884 16 6.11621 16 5.50737V1.10147C16 0.492632 15.5065 0 14.8985 0ZM14.8985 4.95663C14.8985 5.26063 14.6518 5.50737 14.3478 5.50737H11.0433C10.7393 5.50737 10.4926 5.26147 10.4926 4.95663V1.65221C10.4926 1.34821 10.7393 1.10147 11.0433 1.10147H14.3478C14.6518 1.10147 14.8985 1.34737 14.8985 1.65221V4.95663Z' })
            );
          }
      }
    }
    return null;
  },

addActiveClass: function addActiveClass(Tab) {
    var activeTab = findDOMNode(Tab),
        tabItemContainer = activeTab.parentElement,
        tabs = tabItemContainer.children;
    [].forEach.call(tabs, function (tab) {
      tab.classList.remove('active');
    });
    activeTab.classList.add('active');
  },

parseTabSelectedIndex: function parseTabSelectedIndex(index, childSize) {

if (null != index && null != childSize) {
      index = parseInt(index);
      if (!isNaN(index) && -1 < index && index < childSize) {
        return index;
      }
    }
    return 1;
  },

parseCollapseSelectedIndex: function parseCollapseSelectedIndex(index, childSize) {

if (null != index && null != childSize) {
      if ('string' == typeof index || 'number' == typeof index) {
        if ('all' == index) {
          var returnArray = [],
              count = 0;
          for (count; count < childSize; count++) {
            returnArray.push(count.toString());
          }
          return returnArray;
        } else if ('none' == index) {
          return null;
        }
        index = parseInt(index);
        if (!isNaN(index) && -1 < index && index < childSize) {
          return index.toString();
        }
      } else if (Immutable.List.isList(index)) {
        index = index.filter(function (curIndex) {
          curIndex = parseInt(curIndex);
          return !isNaN(curIndex) && -1 < curIndex && curIndex < childSize;
        });
        index = index.map(function (curIndex) {
          return curIndex.toString();
        });
        if (0 < index.size) {
          return index.toArray();
        }
      }
    }
    return '0';
  },

groupAtts: function groupAtts(attsGroupOrName, moduleAttributes, key) {
    if (Immutable.Map.isMap(attsGroupOrName)) {
      if (attsGroupOrName.has('type')) {
        var filteredTitle = attsGroupOrName.get('title');
        if ('tabs' == attsGroupOrName.get('type')) {
          var selectedIndex = attsGroupOrName.get('active');
          selectedIndex = this.parseTabSelectedIndex(selectedIndex, attsGroupOrName.get('group').size);
          if (attsGroupOrName.get('style') === 'style2' && attsGroupOrName.get('group').getIn([0, 'title']) === 'Color' && this.props.targetElement) {
            var moduleValues = this.props.targetElement.get('atts');
            if ('' !== moduleValues.get('bg_video_mp4_src') || '' !== moduleValues.get('bg_video_ogg_src') || '' !== moduleValues.get('bg_video_webm_src')) {
              selectedIndex = 3;
            } else if (moduleValues.get('bg_image') !== '') {
              selectedIndex = 2;
            } else if (moduleValues.get('bg_color') !== '') {
              selectedIndex = 1;
            }
          }

return React.createElement(
            Tabs,
            { key: this.props.targetElement ? this.props.targetElement.get('id') : 0, tabActive: selectedIndex, style: attsGroupOrName.get('style') },
            attsGroupOrName.get('group').map(function (childAttsGroupOrName, index) {
              return this.groupAtts(childAttsGroupOrName, moduleAttributes, index);
            }.bind(this))
          );
        } else if ('tab' == attsGroupOrName.get('type')) {
          return React.createElement(
            TabPane,
            { icon: this.getTabIcon(attsGroupOrName), title: filteredTitle || '', classes: attsGroupOrName.get('border') ? 'be-tab-pane-with-border' : '' },
            attsGroupOrName.get('group').map(function (childAttsGroupOrName, index) {
              return this.groupAtts(childAttsGroupOrName, moduleAttributes, attsGroupOrName.get('title') + index);
            }.bind(this))
          );
        } else if ('panel' == attsGroupOrName.get('type')) {
          if (attsGroupOrName.get('group').some(function (att) {
            if (!Immutable.Map.isMap(att)) {
              return moduleAttributes.has(att);
            } else {
              return true;
            }
          })) {
            if (this.props.filterText && typeof filteredTitle === 'string' && smartSearch(filteredTitle, this.props.filterText)) {
              filteredTitle = searchTextHighlight(this.props.filterText, filteredTitle);
            }
            return React.createElement(
              Panel,
              { className: attsGroupOrName.get('border') ? 'be-collapse-panel-with-border' : '', showArrow: false, header: React.createElement(
                  'div',
                  { className: 'tatsu-panel-header-inner' },
                  React.createElement(
                    'div',
                    { className: 'tatsu-panel-label' },
                    filteredTitle
                  ),
                  React.createElement(
                    'div',
                    { className: 'tatsu-panel-icon' },
                    React.createElement('span', { className: 'tatsu-panel-icon-vert' }),
                    React.createElement('span', { className: 'tatsu-panel-icon-hor' })
                  )
                ) },
              attsGroupOrName.get('group').map(function (childAttsGroupOrName, index) {
                return this.groupAtts(childAttsGroupOrName, moduleAttributes, index);
              }.bind(this))
            );
          }
        } else if ('accordion' == attsGroupOrName.get('type')) {
          var selectedIndex = attsGroupOrName.get('active') || '0';
          selectedIndex = this.parseCollapseSelectedIndex(selectedIndex, attsGroupOrName.get('group').size);
          return React.createElement(
            Collapse,
            { accordion: false, key: key, className: 'be-ui-collapse', defaultActiveKey: selectedIndex },
            attsGroupOrName.get('group').map(function (childAttsGroupOrName, index) {
              return this.groupAtts(childAttsGroupOrName, moduleAttributes);
            }.bind(this))
          );
        }
      }
    } else {
      if (attsGroupOrName === 'tatsu_builtin_layout') {
        return React.createElement(LayoutTabContent, { moduleOptions: this.props.moduleOptions, module: this.props.targetElement, addPadding: true, moduleChildren: this.props.targetElement.get('inner'), path: this.props.modulePath, builderMode: this.props.builderMode });
      }
      var attsFromModuleOptions = this.props.attsFromModuleOptions,
          targetDisplay = this.props.targetDisplay,
          moduleOptions = this.props.moduleOptions,
          moduleId = Immutable.Map.isMap(this.props.targetElement) ? this.props.targetElement.get('id') : '',
          path = this.props.modulePath,
          moduleName = this.props.moduleName,
          attMap = attsFromModuleOptions.find(function (attData) {

if (moduleName === 'tatsu_header_column') {
          if (attData.has('hide_in_header_col') && attData.get('hide_in_header_col') === true) {
            return null;
          }
        }
        if (moduleName === 'tatsu_slide_menu_column') {
          if (attData.has('hide_in_sidebar_col') && attData.get('hide_in_sidebar_col') === true) {
            return null;
          }
        }
        return attsGroupOrName == attData.get('att_name');
      }),
          attName = '',
          attValue = '';

if (attMap) {
        if ((!attMap.has('device_visibility') || attMap.has('device_visibility') && attMap.get('device_visibility') === targetDisplay) && !(targetDisplay === 'desktop' && this.props.isMultiSelected && attMap.has('multiselect') && !attMap.get('multiselect'))) {
          attName = attMap.get('att_name');
          attValue = moduleAttributes.get(attName);
          if (attMap.has('visible') || attMap.has('hidden')) {
            var condition = attMap.get('visible') || attMap.get('hidden');
            if (attMap.has('visible') && checkConditionalAtts(condition, moduleAttributes, attName, moduleName)) {
              return editorFields.getEditorFields(attValue, attMap, path, moduleName, moduleOptions, targetDisplay, moduleId, this.props.completeAtts, this.props.filterText);
            } else if (attMap.has('hidden') && !checkConditionalAtts(condition, moduleAttributes, attName, moduleName)) {
              return editorFields.getEditorFields(attValue, attMap, path, moduleName, moduleOptions, targetDisplay, moduleId, this.props.completeAtts, this.props.filterText);
            }
          } else {
            return editorFields.getEditorFields(attValue, attMap, path, moduleName, moduleOptions, targetDisplay, moduleId, this.props.completeAtts, this.props.filterText);
          }
        }
      }
    }
    return null;
  },

routeHandler: function routeHandler(path, attsToList, targetElement, moduleOptions, isMultiSelected) {
    if (!Immutable.OrderedMap.isOrderedMap(attsToList) || !Immutable.List.isList(this.props.attsFromModuleOptions)) {
      return null;
    } else if (Immutable.Map.isMap(targetElement) && this.props.moduleName && targetElement.get('name') != this.props.moduleName && 'multi' != this.props.moduleOptions.getIn([this.props.moduleName, 'type'])) {
      return null;
    } else {
      var targetDisplay = this.props.targetDisplay,
          moduleId = Immutable.Map.isMap(this.props.targetElement) ? this.props.targetElement.get('id') : '',
          moduleName = this.props.moduleName,
          moduleAttributes = this.props.attsToList,
          attsFromModuleOptions = this.props.attsFromModuleOptions,
          editorOutput = [];
      if (!this.props.enableGrouping) {
        moduleAttributes.forEach(function (attValue, attKey) {

var currentAttributeMap = Immutable.Map();
          currentAttributeMap = attsFromModuleOptions.find(function (element) {

if (attKey === element.get('att_name')) {
              return true;
            }
          }) || Immutable.Map();

if (moduleName === 'tatsu_header_column') {
            if (currentAttributeMap.has('hide_in_header_col') && currentAttributeMap.get('hide_in_header_col') === true) {
              return null;
            }
          }
          if (moduleName === 'tatsu_slide_menu_column') {
            if (currentAttributeMap.has('hide_in_sidebar_col') && currentAttributeMap.get('hide_in_sidebar_col') === true) {
              return null;
            }
          }

if (0 < currentAttributeMap.size && (!currentAttributeMap.has('device_visibility') || currentAttributeMap.has('device_visibility') && currentAttributeMap.get('device_visibility') === targetDisplay) && !(targetDisplay === 'desktop' && isMultiSelected && currentAttributeMap.has('multiselect') && !currentAttributeMap.get('multiselect'))) {
            if (currentAttributeMap.has('visible') || currentAttributeMap.has('hidden')) {
              var condition = currentAttributeMap.get('visible') || currentAttributeMap.get('hidden');
              if (currentAttributeMap.has('visible') && checkConditionalAtts(condition, moduleAttributes, attKey, moduleName)) {
                editorOutput.push(editorFields.getEditorFields(attValue, currentAttributeMap, path, moduleName, moduleOptions, targetDisplay, moduleId, this.props.completeAtts, this.props.filterText));
              } else if (currentAttributeMap.has('hidden') && !checkConditionalAtts(condition, moduleAttributes, attKey, moduleName)) {
                editorOutput.push(editorFields.getEditorFields(attValue, currentAttributeMap, path, moduleName, moduleOptions, targetDisplay, moduleId, this.props.completeAtts, this.props.filterText));
              }
            } else {
              editorOutput.push(editorFields.getEditorFields(attValue, currentAttributeMap, path, moduleName, moduleOptions, targetDisplay, moduleId, this.props.completeAtts, this.props.filterText));
            }
          }
        }.bind(this));
      } else {
        var attsGroup = this.props.filteredGroupAtts; //moduleConfig.get( 'group_atts' );
        if (Immutable.List.isList(attsGroup)) {
          attsGroup.forEach(function (attsGroupOrName, index) {
            editorOutput.push(this.groupAtts(attsGroupOrName, moduleAttributes, index));
          }.bind(this));
        } else if (Immutable.Map.isMap(attsGroup)) {
          editorOutput = this.groupAtts(attsGroup, moduleAttributes, 1);
        }
      }
      return React.createElement(
        'ul',
        { className: 'be-editor-field-list' },
        editorOutput
      );
    }
  },

componentDidMount: function componentDidMount() {

if ('undefined' == typeof this.props.modulePath) {
      store.dispatch(resetSelection());
    }
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
  },

componentDidUpdate: function componentDidUpdate() {

if ('undefined' == typeof this.props.modulePath) {
      store.dispatch(resetSelection());
    }
  },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

render: function render() {
    var _this = this;

var pageContent = this.props.pageContent,
        path = this.props.modulePath,
        isMultiSelected = this.props.isMultiSelected,
        moduleOptions = this.props.moduleOptions,
        moduleId = this.props.moduleId,
        targetElement = this.props.targetElement,
        attsToList = this.props.attsToList,
        completeAtts = this.props.completeAtts,
        currentModule,
        duplicateBtnStyle = {},
        showBackBtn = false,
        backBtnTitle = '',
        childModuleName = this.props.moduleName;
    currentModule = this.routeHandler(path, attsToList, targetElement, moduleOptions, isMultiSelected);

if (['tatsu_column', 'tatsu_inner_column', 'tatsu_slide_menu_column', 'tatsu_header_column'].indexOf(this.props.moduleName) > -1) {
      duplicateBtnStyle = { pointerEvents: 'none', opacity: '0.3' };
    }

if (this.props.builderMode === 'header_builder') {
      showBackBtn = this.props.modulePath.size === 6 || this.props.modulePath.size === 4;
      if (moduleOptions.getIn([childModuleName, 'title'])) {
        backBtnTitle = moduleOptions.getIn([childModuleName, 'title']) + 's';
      } else {
        backBtnTitle = 'Columns';
      }
    } else {
      showBackBtn = (this.props.modulePath.size === 5 || this.props.modulePath.size === 7) && this.props.moduleName !== 'tatsu_inner_column';
      if (moduleOptions.getIn([childModuleName, 'title'])) {
        backBtnTitle = moduleOptions.getIn([childModuleName, 'title']) + 's';
      } else {
        backBtnTitle = 'Items';
      }
    }

return React.createElement(
      'div',
      { className: 'be-pb-editor' },
      Immutable.OrderedMap.isOrderedMap(completeAtts) ? React.createElement(
        'div',
        null,
        React.createElement(
          'div',
          { className: 'be-pb-builder-actions' },
          React.createElement(
            'div',
            { className: 'be-pb-builder-action delete', onClick: function onClick() {
                return store.dispatch(deleteModule(_this.props.modulePath, _this.props.moduleName));
              } },
            React.createElement(
              'div',
              { className: 'be-pb-builder-action-icon' },
              React.createElement(
                'svg',
                { viewBox: '0 0 100 100' },
                React.createElement('path', { d: 'M67.6683908,76.9065599 C67.632523,77.7673863 66.8667215,78.5 65.9999745,78.5 L34.0000255,78.5 C33.1336268,78.5 32.3673911,77.7653262 32.3316092,76.9065599 L30.4978327,32.8959236 C30.4403529,31.5164087 29.2754385,30.4446875 27.8959236,30.5021673 C26.5164087,30.5596471 25.4446875,31.7245615 25.5021673,33.1040764 L27.3359438,77.1147127 C27.4833334,80.6520627 30.453619,83.5 34.0000255,83.5 L65.9999745,83.5 C69.5442642,83.5 72.5164778,80.6565944 72.6640562,77.1147127 L74.4978327,33.1040764 C74.5553125,31.7245615 73.4835913,30.5596471 72.1040764,30.5021673 C70.7245615,30.4446875 69.5596471,31.5164087 69.5021673,32.8959236 L67.6683908,76.9065599 Z M48,71 C48,72.1045695 48.8954305,73 50,73 C51.1045695,73 52,72.1045695 52,71 L52,37 C52,35.8954305 51.1045695,35 50,35 C48.8954305,35 48,35.8954305 48,37 L48,71 Z M38.0008645,71.0587981 C38.0333378,72.1628902 38.954706,73.0316088 40.0587981,72.9991355 C41.1628902,72.9666622 42.0316088,72.045294 41.9991355,70.9412019 L40.9991355,36.9412019 C40.9666622,35.8371098 40.045294,34.9683912 38.9412019,35.0008645 C37.8371098,35.0333378 36.9683912,35.954706 37.0008645,37.0587981 L38.0008645,71.0587981 Z M58.0008645,70.9412019 C57.9683912,72.045294 58.8371098,72.9666622 59.9412019,72.9991355 C61.045294,73.0316088 61.9666622,72.1628902 61.9991355,71.0587981 L62.9991355,37.0587981 C63.0316088,35.954706 62.1628902,35.0333378 61.0587981,35.0008645 C59.954706,34.9683912 59.0333378,35.8371098 59.0008645,36.9412019 L58.0008645,70.9412019 Z M62.314325,22 L61.3628045,18.6696783 C60.5262772,15.741833 57.5532275,13.5 54.5085033,13.5 L45.4914967,13.5 C42.4471337,13.5 39.4734928,15.742638 38.6371955,18.6696783 L37.685675,22 L25,22 C23.6192881,22 22.5,23.1192881 22.5,24.5 C22.5,25.8807119 23.6192881,27 25,27 L75,27 C76.3807119,27 77.5,25.8807119 77.5,24.5 C77.5,23.1192881 76.3807119,22 75,22 L62.314325,22 L62.314325,22 Z M54.5085033,18.5 L45.4914967,18.5 C44.6793677,18.5 43.6677785,19.2629127 43.4448153,20.0432839 L42.8857535,22 L57.1142465,22 L56.5551847,20.0432839 C56.3320347,19.2622589 55.3211505,18.5 54.5085033,18.5 Z' })
              )
            ),
            React.createElement(
              'div',
              { className: 'be-pb-builder-action-title' },
              'DELETE'
            )
          ),
          React.createElement(
            'div',
            { className: 'be-pb-builder-action duplicate', style: duplicateBtnStyle, onClick: function onClick() {
                return store.dispatch(duplicateModule(_this.props.modulePath, _this.props.moduleName));
              } },
            React.createElement(
              'div',
              { className: 'be-pb-builder-action-icon' },
              React.createElement(
                'svg',
                { viewBox: '0 0 100 100' },
                React.createElement('path', { d: 'M86,14H27.5v58.5H86V14z M80.1,66.6H33.4V19.9h46.7V66.6z M69.5,86H14V30.5h5.9v49.7h49.7V86z M53.8,46.2  H42.4v-5.9h11.4V28.9h5.9v11.4h11.4v5.9H59.7v11.4h-5.9V46.2z' })
              )
            ),
            React.createElement(
              'div',
              { className: 'be-pb-builder-action-title' },
              'DUPLICATE'
            )
          )
        ),
        React.createElement(
          'div',
          { className: 'be-pb-module-search-wrapper' },
          React.createElement(
            'div',
            { className: 'be-pb-module-search' },
            React.createElement('input', { placeholder: 'Search Options', value: this.props.filterText, onChange: this.props.changeFilterText, type: 'text', className: 'be-pb-module-search-input' }),
            React.createElement(
              'div',
              { className: 'be-pb-module-search-icon' },
              React.createElement(
                'svg',
                { width: '12px', height: '12px', viewBox: '0 0 12 12', version: '1.1', xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink' },
                React.createElement(
                  'g',
                  { id: 'Desktop-HD', stroke: 'none', strokeWidth: '1', fillRule: 'evenodd', transform: 'translate(-264.000000, -52.000000)' },
                  React.createElement(
                    'g',
                    { id: 'Search', transform: 'translate(-1.000000, 40.000000)', fillRule: 'nonzero' },
                    React.createElement(
                      'g',
                      { id: 'noun_905006', transform: 'translate(265.000000, 12.000000)' },
                      React.createElement('path', { d: 'M8.44171779,7.84976526 C9.24662577,7.00469484 9.73742331,5.91549296 9.73742331,4.69483568 C9.73742331,2.10328638 7.55828221,0 4.86871166,0 C2.1791411,0 0,2.10328638 0,4.657277 C0,7.21126761 2.19877301,9.31455399 4.86871166,9.31455399 C5.88957055,9.31455399 6.85153374,8.99530516 7.59754601,8.50704225 L11.0920245,11.8497653 C11.209816,11.9624413 11.3276074,12 11.4650307,12 C11.602454,12 11.7398773,11.943662 11.8380368,11.8497653 C12.0539877,11.6431925 12.0539877,11.3239437 11.8380368,11.1173709 L8.44171779,7.84976526 Z M4.88834356,8.28169014 C2.80736196,8.28169014 1.0993865,6.64788732 1.0993865,4.657277 C1.0993865,2.66666667 2.80736196,1.03286385 4.88834356,1.03286385 C6.96932515,1.03286385 8.67730061,2.66666667 8.67730061,4.657277 C8.67730061,6.64788732 6.98895706,8.28169014 4.88834356,8.28169014 Z', id: 'Shape' })
                    )
                  )
                )
              )
            )
          )
        )
      ) : null,
      showBackBtn && React.createElement(
        'div',
        { className: 'be-pb-back-to-group', onClick: function onClick() {
            return store.dispatch(setSelection(_this.props.modulePath.pop(), 'single'));
          } },
        ' \u27F5 Back to all ',
        backBtnTitle,
        ' '
      ),
      currentModule
    );
  }
});
module.exports = ModuleEditor;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 666 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var ModuleEditor = __webpack_require__(665),
    getPathArray = __webpack_require__(39),
    getAttBasedOnDisplay = __webpack_require__(53),
    getSerializedPath = __webpack_require__(715),
    checkConditionalAtts = __webpack_require__(365),
    smartSearch = __webpack_require__(158),
    getElementFromRoutePath = __webpack_require__(368);
var ModuleEditorWrapper = React.createClass({
    displayName: 'ModuleEditorWrapper',

attsClassification: null,
    getInitialState: function getInitialState() {
        return {
            filter: ''
        };
    },
    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        if ((this.props.modulePath != nextProps.modulePath || this.props.moduleId != nextProps.moduleId) && '' != this.state.filter) {
            this.setState({
                filter: ''
            });
        }
        if ('multiSelect' == this.props.modulePath && 'multiSelect' == nextProps.modulePath && !Immutable.is(this.props.selectionState, nextProps.selectionState) && '' != this.state.filter) {
            this.setState({
                filter: ''
            });
        }
    },
    changeFilter: function changeFilter(e) {
        this.setState({
            filter: e.target.value
        });
    },
    getTargetElement: function getTargetElement() {
        var targetElement = null;
        if ('multiSelect' != this.props.modulePath) {
            targetElement = getElementFromRoutePath(this.props.builderMode, this.props.pageContent, this.props.modulePath);
        }
        return targetElement;
    },
    getAttsForMultiSelectedModules: function getAttsForMultiSelectedModules(attsFromModuleConfig) {
        var moduleAtts = Immutable.OrderedMap(),
            selectionList = this.props.selectionState.get('selectionList'),
            targetDisplay = this.props.targetDisplay[0];
        moduleAtts = selectionList.reduce(function (moduleAtts, selection) {
            var pathArray = getPathArray(selection.get('path')),
                curElement = this.props.pageContent.getIn(pathArray);
            if (0 == moduleAtts.size) {
                moduleAtts = curElement.get('atts');
            } else {
                moduleAtts = moduleAtts.map(function (attValue, attKey) {
                    if (Immutable.Map.isMap(attValue)) {
                        if (attValue.get('d') ? attValue.get(targetDisplay) !== curElement.getIn(['atts', attKey, targetDisplay]) : Immutable.is(attValue, curElement.getIn(['atts', attKey]))) {
                            var attMap = attsFromModuleConfig.find(function (attMap) {
                                return attMap.get('att_name') == attKey;
                            });
                            if (null != attMap) {
                                if ('color' == attMap.get('type')) {
                                    return '';
                                } else {
                                    return Immutable.Map({ d: '', l: null, t: null, m: null });
                                }
                            } else {
                                return '';
                            }
                        } else {
                            return attValue;
                        }
                    } else if (attValue != curElement.getIn(['atts', attKey])) {
                        return '';
                    } else {
                        return attValue;
                    }
                });
            }
            return moduleAtts;
        }.bind(this), moduleAtts);
        return moduleAtts;
    },

getFilteredAtts: function getFilteredAtts(moduleAtts) {
        var filterText = this.state.filter,
            attsFromModuleConfig = this.props.moduleOptions.getIn([this.props.selectionState.getIn(['selectionList', 0, 'name']), 'atts']),
            filteredAtts = null;
        filteredAtts = moduleAtts.filter(function (attValue, attKey) {
            var attMapData = attsFromModuleConfig.find(function (attMap) {
                return attMap.get('att_name') == attKey;
            });
            if (Immutable.Map.isMap(attMapData)) {
                var attLabel = attMapData.get('label');
                return 'string' == typeof attLabel && -1 < attLabel.toLowerCase().indexOf(filterText.toLowerCase());
            }
            return false;
        });
        return filteredAtts ? filteredAtts : null;
    },

getFilteredGroupAtts: function getFilteredGroupAtts(moduleName, attsToList) {

var filterText = this.state.filter,
            moduleConfig = this.props.moduleOptions.get(moduleName),
            attsFromModuleConfig = moduleConfig.get('atts'),
            groupAttsFromModuleConfig = moduleConfig.get('group_atts');

if (!groupAttsFromModuleConfig) {
            return Immutable.Map();
        }

function isAttVisible(attName) {
            var attData = attsFromModuleConfig.find(function (attMap) {
                return attName === attMap.get('att_name');
            });

if (!attData.get('visible') && !attData.get('hidden')) {
                return true;
            }

var condition = attData.get('visible');
            if (condition && checkConditionalAtts(condition, attsToList, attName, moduleName)) {
                return true;
            }
            condition = attData.get('hidden');
            if (condition && !checkConditionalAtts(condition, attsToList, attName, moduleName)) {
                return true;
            }
            return false;
        }

var allPanelsAndAtts = Immutable.List();

function getAttsAndContainers(mapItem) {

if (!mapItem) {
                return;
            }
            if (typeof mapItem === 'string') {
                allPanelsAndAtts = allPanelsAndAtts.push(mapItem);
                return;
            }
            if (!mapItem.get) {
                //handles "tatsu_builtin_layout" case
                return;
            }
            if (mapItem.get('type') === 'panel') {
                allPanelsAndAtts = allPanelsAndAtts.push(mapItem);
                return;
            } else {
                if (Immutable.List.isList(mapItem)) {
                    mapItem.forEach(function (element) {
                        getAttsAndContainers(element);
                    });
                } else {
                    getAttsAndContainers(mapItem.get('group'));
                }
            }
            return allPanelsAndAtts;
        }

var finalAttsStrings = Immutable.List();

allPanelsAndAtts = getAttsAndContainers(groupAttsFromModuleConfig);
        var filteredAtts = cmpAttss(allPanelsAndAtts);
        var filteredGroupAtts = Immutable.List([Immutable.Map({
            type: 'accordion',
            active: 'all',
            group: filteredAtts
        })]).concat(finalAttsStrings);

return filteredGroupAtts;
    },
    getModuleConfig: function getModuleConfig() {
        var targetElement = this.getTargetElement();
        if (null != targetElement) {
            return this.props.moduleOptions.get(targetElement.get('name'));
        } else if (0 < this.props.selectionState.get('selectionList').size) {
            if ('single' === this.props.selectionState.get('type') || 'multi' === this.props.selectionState.get('type') && 'similar' === this.props.selectionState.get('multiType')) {
                return this.props.moduleOptions.get(this.props.selectionState.getIn(['selectionList', 0, 'name']));
            }
        }
        return null;
    },
    checkIfGroupingIsPossible: function checkIfGroupingIsPossible() {
        var moduleConfig = this.getModuleConfig();
        return moduleConfig && 'miscellaneous' != this.props.selectionState.get('multiType') && moduleConfig.has('group_atts');
    },
    getParsedAtts: function getParsedAtts(atts) {
        var moduleConfig = this.getModuleConfig(),
            parsedAtts = atts,
            attsFromModuleConfig;
        if (null != atts) {
            if ('' != this.state.filter) {
                parsedAtts = this.getFilteredAtts(atts);
            }
            if (moduleConfig) {
                attsFromModuleConfig = moduleConfig.get('atts');
                parsedAtts = getAttBasedOnDisplay(parsedAtts, this.props.targetDisplay, attsFromModuleConfig);
            }
        }
        return parsedAtts;
    },
    render: function render() {
        var targetElement = this.getTargetElement(),
            enableGrouping = this.checkIfGroupingIsPossible(),
            moduleConfig = this.getModuleConfig(),
            attsFromModuleConfig = moduleConfig ? moduleConfig.get('atts') : null,
            selectionType = this.props.selectionState.get('type'),
            moduleName = 'single' == selectionType && null != targetElement ? targetElement.get('name') : 'multi' == selectionType && 'similar' == this.props.selectionState.get('multiType') ? this.props.selectionState.getIn(['selectionList', 0, 'name']) : null,

//moduleName = '' != selectionType && 'miscellaneous' != this.props.selectionState.get( 'multiType' ) ? this.props.selectionState.getIn( [ 'selectionList', 0, 'name' ] ) : null,
        path = getSerializedPath(this.props.modulePath, this.props.selectionState),
            isMultiSelected = 'multi' == selectionType ? true : false,
            attsToList = 'single' == selectionType && null != targetElement ? targetElement.get('atts') : 'similar' == this.props.selectionState.get('multiType') ? this.getAttsForMultiSelectedModules(attsFromModuleConfig) : null,
            parsedAtts = this.getParsedAtts(attsToList),
            filteredGroupAtts = this.state.filter ? this.getFilteredGroupAtts(moduleName, attsToList) : moduleConfig ? moduleConfig.get('group_atts') : null;
        return React.createElement(ModuleEditor
        // key = { Immutable.Map.isMap( targetElement ) ? targetElement.get( 'id' ) : 'multi' }
        , { enableGrouping: enableGrouping,
            moduleConfig: moduleConfig,
            targetElement: targetElement,
            moduleName: moduleName,
            modulePath: path,
            isMultiSelected: isMultiSelected,
            filterText: this.state.filter,
            changeFilterText: this.changeFilter,
            moduleId: this.props.moduleId,
            pageContent: this.props.pageContent,
            completeAtts: attsToList,
            attsToList: parsedAtts,
            filteredGroupAtts: filteredGroupAtts,
            attsFromModuleOptions: attsFromModuleConfig,
            moduleOptions: this.props.moduleOptions,
            targetDisplay: this.props.targetDisplay,
            builderMode: this.props.builderMode
        });
    }
});
module.exports = ModuleEditorWrapper;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 667 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var findDOMNode = __webpack_require__(7).findDOMNode,
    Link = __webpack_require__(40).Link,
    routeResolve = __webpack_require__(33);
__webpack_require__(907);

var InputPanel = React.createClass({
    displayName: 'InputPanel',

scrollToTop: false,
    propTypes: {},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

var newPath = nextProps.routeProps.location.pathname,
            currentId,
            newId;
        if (-1 < newPath.indexOf('moduleEditor')) {
            currentId = this.props.routeProps.params.moduleId;
            newId = nextProps.routeProps.params.moduleId;
            if (currentId != newId) {
                this.scrollToTop = true;
            }
        }
    },

componentDidUpdate: function componentDidUpdate() {

if (this.scrollToTop) {
            var parentWrap = findDOMNode(this),
                scrollArea;
            if (null != parentWrap) {
                scrollArea = parentWrap.children[0].children[0];
                scrollArea.scrollTop = 0;
            }
            this.scrollToTop = false;
        }
    },

getActiveLink: function getActiveLink(currentRoute) {
        if (-1 < currentRoute.indexOf('layoutManager')) {
            return 'layoutManager';
        } else if (-1 < currentRoute.indexOf('moduleList')) {
            return 'moduleList';
        } else if (-1 < currentRoute.indexOf('globalSettings')) {
            return 'globalSettings';
        } else if (-1 < currentRoute.indexOf('tatsuRevisions')) {
            return 'tatsuRevisions';
        } else {
            return 'layoutManager';
        }
    },

getCurTitle: function getCurTitle() {
        var selectionState = this.props.selectionState,
            currentRoute = this.props.routeProps.location.pathname;
        if (-1 < currentRoute.indexOf('layoutManager')) {
            return 'Tree View';
        } else if (-1 < currentRoute.indexOf('moduleList')) {
            return 'Modules List';
        } else if ('' !== selectionState.get('type')) {
            if ('single' === selectionState.get('type')) {
                return selectionState.getIn(['selectionList', 0, 'title']);
            } else {
                return 'Multi Select';
            }
        } else if (-1 < currentRoute.indexOf('globalSettings')) {
            return 'Global Settings';
        } else if (-1 < currentRoute.indexOf('tatsuRevisions')) {
            return 'Revisions';
        } else {
            return 'Home';
        }
    },

render: function render() {

var currentRoute = this.props.routeProps.location.pathname,
            curActiveLink = this.getActiveLink(currentRoute),
            parentRoute = routeResolve(currentRoute);
        return React.createElement(
            'div',
            { id: 'be-pb-leftpanel-outer-wrap' },
            React.createElement(
                'div',
                { id: 'be-pb-leftpanel-content-wrap' },
                React.createElement(
                    'div',
                    { id: 'be-pb-leftpanel-inner-wrap' },
                    React.createElement(
                        'div',
                        { id: 'be-pb-leftpanel' },
                        React.createElement(
                            'ul',
                            { id: 'be-pb-leftPanel-tab-links' },
                            React.createElement(
                                'li',
                                { className: 'be-pb-leftpanel-title' },
                                React.createElement(
                                    'div',
                                    { className: 'be-pb-leftpanel-title-inner' },
                                    this.getCurTitle()
                                )
                            ),
                            React.createElement(
                                Link,
                                { activeClassName: 'active', to: parentRoute + "layoutManager/" },
                                React.createElement(
                                    'li',
                                    { className: "be-pb-leftPanel-tab-link " + ('layoutManager' == curActiveLink ? 'active' : '') },
                                    React.createElement(
                                        'svg',
                                        { xmlns: 'http://www.w3.org/2000/svg', width: '19', height: '12', viewBox: '0 0 19 12' },
                                        React.createElement('path', { fillRule: 'evenodd', clipRule: 'evenodd', d: 'M18.775 5.48067L18.2004 4.87757C16.1522 2.7048 13.6008 0 9.50049 0C5.42463 0 2.70022 2.87334 0.709684 4.97199L0.224998 5.48067C-0.0749993 5.79237 -0.0749993 6.29596 0.224998 6.60665L0.616851 7.01582C2.62205 9.11955 5.36795 12 9.50049 12C13.6535 12 16.2236 9.29317 18.2835 7.11938L18.775 6.60564C19.075 6.29596 19.075 5.79237 18.775 5.48067ZM9.50049 10.408C6.08716 10.408 3.82888 8.11947 1.84616 6.04214C3.83474 3.94754 6.09303 1.59303 9.50049 1.59303C12.9558 1.59303 15.1604 3.92927 17.1069 5.99137L17.1548 6.04315C15.2053 8.09713 12.99 10.408 9.50049 10.408Z' }),
                                        React.createElement('path', { fillRule: 'evenodd', clipRule: 'evenodd', d: 'M9.5 7C10.3284 7 11 6.32843 11 5.5C11 4.67157 10.3284 4 9.5 4C8.67157 4 8 4.67157 8 5.5C8 6.32843 8.67157 7 9.5 7Z' })
                                    )
                                )
                            ),
                            React.createElement(
                                Link,
                                { activeClassName: 'active', to: parentRoute + "moduleList/" },
                                React.createElement(
                                    'li',
                                    { className: "be-pb-leftPanel-tab-link " + ('moduleList' == curActiveLink ? 'active' : '') },
                                    React.createElement(
                                        'svg',
                                        { width: '15', height: '15', viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg' },
                                        React.createElement('path', { fillRule: 'evenodd', clipRule: 'evenodd', d: 'M6.08671 8.81179H1.68082C1.07198 8.81179 0.579346 9.30611 0.579346 9.91411V14.32C0.579346 14.928 1.07198 15.4215 1.68082 15.4215H6.08671C6.69556 15.4215 7.18819 14.928 7.18819 14.32V9.91411C7.18819 9.30611 6.69471 8.81179 6.08671 8.81179ZM6.08671 13.7693C6.08671 14.0733 5.83998 14.32 5.53598 14.32H2.23071C1.92671 14.32 1.67998 14.0733 1.67998 13.7693V10.4648C1.67998 10.1608 1.92587 9.91411 2.23071 9.91411H5.53514C5.83914 9.91411 6.08587 10.1608 6.08587 10.4648V13.7693H6.08671ZM14.8985 8.81179H10.4926C9.88377 8.81179 9.39114 9.30611 9.39114 9.91411V14.32C9.39114 14.928 9.88377 15.4215 10.4926 15.4215H14.8985C15.5065 15.4215 16 14.928 16 14.32V9.91411C16 9.30611 15.5065 8.81179 14.8985 8.81179ZM14.8985 13.7693C14.8985 14.0733 14.6518 14.32 14.3478 14.32H11.0433C10.7393 14.32 10.4926 14.0733 10.4926 13.7693V10.4648C10.4926 10.1608 10.7393 9.91411 11.0433 9.91411H14.3478C14.6518 9.91411 14.8985 10.1608 14.8985 10.4648V13.7693ZM6.08671 0H1.68082C1.07198 0 0.579346 0.492632 0.579346 1.10147V5.50737C0.579346 6.11621 1.07198 6.60884 1.68082 6.60884H6.08671C6.69556 6.60884 7.18819 6.11621 7.18819 5.50737V1.10147C7.18819 0.492632 6.69471 0 6.08671 0ZM6.08671 4.95663C6.08671 5.26063 5.83998 5.50737 5.53598 5.50737H2.23071C1.92671 5.50737 1.67998 5.26147 1.67998 4.95663V1.65221C1.67998 1.34821 1.92587 1.10147 2.23071 1.10147H5.53514C5.83914 1.10147 6.08587 1.34737 6.08587 1.65221V4.95663H6.08671ZM14.8985 0H10.4926C9.88377 0 9.39114 0.492632 9.39114 1.10147V5.50737C9.39114 6.11621 9.88377 6.60884 10.4926 6.60884H14.8985C15.5065 6.60884 16 6.11621 16 5.50737V1.10147C16 0.492632 15.5065 0 14.8985 0ZM14.8985 4.95663C14.8985 5.26063 14.6518 5.50737 14.3478 5.50737H11.0433C10.7393 5.50737 10.4926 5.26147 10.4926 4.95663V1.65221C10.4926 1.34821 10.7393 1.10147 11.0433 1.10147H14.3478C14.6518 1.10147 14.8985 1.34737 14.8985 1.65221V4.95663Z' })
                                    )
                                )
                            ),
                            React.createElement(
                                Link,
                                { activeClassName: 'active', to: parentRoute + "globalSettings/" },
                                React.createElement(
                                    'li',
                                    { className: "be-pb-leftPanel-tab-link " },
                                    React.createElement(
                                        'svg',
                                        { role: 'img', width: '16', height: '16', className: 'be-pb-navigation-svg-icon', viewBox: '0 0 20 20' },
                                        React.createElement('use', { xlinkHref: tatsuConfig.svgs + '#icon-settings' })
                                    )
                                )
                            )
                        ),
                        this.props.routeProps.children
                    )
                )
            )
        );
    }

});
module.exports = InputPanel;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 668 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _birdsEyeViewList = __webpack_require__(214);

var _birdsEyeViewList2 = _interopRequireDefault(_birdsEyeViewList);

var _columnElements = __webpack_require__(672);

var _columnElements2 = _interopRequireDefault(_columnElements);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LayoutTabContent = function LayoutTabContent(props) {
    return React.createElement(
        'div',
        null,
        'multi' === props.module.get('type') && props.module.get('name') !== 'tatsu_inner_row' ? React.createElement(_birdsEyeViewList2.default, { moduleOptions: props.moduleOptions, moduleChildren: props.module.get('inner'), isLayoutPanel: true, path: props.path, module: props.module }) : '',
        ['tatsu_row', 'tatsu_inner_row', 'tatsu_header_row'].indexOf(props.module.get('name')) > -1 && React.createElement(_columnElements2.default, { builderMode: props.builderMode, target: props.module, path: props.path, moduleOptions: props.moduleOptions, builderMode: props.builderMode })
    );
};

exports.default = LayoutTabContent;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 669 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var openDrawer = __webpack_require__(2).openDrawer,
    addModule = __webpack_require__(2).addModule,
    listChecker = __webpack_require__(16).listChecker,
    Immutable = __webpack_require__(3),
    store = __webpack_require__(11);
var AddModules = React.createClass({
  displayName: 'AddModules',

propTypes: {
    path: listChecker,
    label: React.PropTypes.string.isRequired,
    name: React.PropTypes.string.isRequired
  },
  moduleAddHandler: function moduleAddHandler() {

if ('module' == this.props.name) {
      store.dispatch(openDrawer('modulelist', Immutable.Map({ path: this.props.path, position: '', addType: 'push' })));
    } else {
      store.dispatch(addModule(this.props.path, this.props.name, 'push'));
    }
    // store.dispatch( 
    //   changeTargetDisplay( 'desktop' ) 
    // );
  },

render: function render() {

/***/ }),
/* 670 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function($, Immutable, React, jQuery) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _tooltip = __webpack_require__(58);

var _tooltip2 = _interopRequireDefault(_tooltip);

var _menu = __webpack_require__(91);

var _menu2 = _interopRequireDefault(_menu);

__webpack_require__(59);

__webpack_require__(92);

var _birdsEyeViewList = __webpack_require__(214);

var _birdsEyeViewList2 = _interopRequireDefault(_birdsEyeViewList);

var _popoverMenu = __webpack_require__(154);

var _popoverMenu2 = _interopRequireDefault(_popoverMenu);

var _reactDnd = __webpack_require__(37);

var _dndConstants = __webpack_require__(79);

var _reducer = __webpack_require__(11);

var _reducer2 = _interopRequireDefault(_reducer);

var _reactDom = __webpack_require__(7);

var _flow = __webpack_require__(60);

var _flow2 = _interopRequireDefault(_flow);

var _throttle = __webpack_require__(296);

var _throttle2 = _interopRequireDefault(_throttle);

var _scrollToSelectedNode = __webpack_require__(241);

var _scrollToSelectedNode2 = _interopRequireDefault(_scrollToSelectedNode);

var _getDropTargetPath = __webpack_require__(238);

var _getDropTargetPath2 = _interopRequireDefault(_getDropTargetPath);

var _actionCreator = __webpack_require__(2);

var _uiConstants = __webpack_require__(95);

__webpack_require__(908);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var encodePath = __webpack_require__(43).encodePath,
    routeResolve = __webpack_require__(33),
    browserHistory = __webpack_require__(40).browserHistory;

var Item = _menu2.default.Item;

var throttledHandler = (0, _throttle2.default)(mouseMoveHandler, 300);
function mouseMoveHandler(e) {

var thresholdY = 100,
        thresholdX = 300,
        windowHeight = window.innerHeight,
        scrollParent = $('#be-pb-leftpanel-inner-wrap');

if (e.pageX === 0 && e.pageY === 0) {
        return;
    }

if (e.pageX < thresholdX) {
        if (e.pageY !== 0 && e.pageY < thresholdY) {
            scrollParent.scrollTop(scrollParent.scrollTop() - 100);
        } else if (e.pageY > windowHeight - thresholdY) {
            scrollParent.scrollTop(scrollParent.scrollTop() + 100);
        }
    }
}

var dragSpec = {
    isDragging: function isDragging(props, monitor) {
        return Immutable.is(props.path, monitor.getItem().path);
    },
    beginDrag: function beginDrag(props, monitor, component) {
        _reducer2.default.dispatch((0, _actionCreator.startDrag)('birdsEyeView'));

if (props.open) {
            props.toggleState(props.open);
        }
        $(document).on('dragover', throttledHandler);

return {
            path: props.path,
            module: props.module
        };
    },
    endDrag: function endDrag(props) {
        _reducer2.default.dispatch((0, _actionCreator.endDrag)());
        $(document).off('dragover', throttledHandler);
        if ('multi' === props.moduleOptions.getIn([props.parentModule.get('name'), 'type']) && !props.moduleOptions.getIn([props.parentModule.get('name'), 'is_built_in'])) {
            _reducer2.default.dispatch((0, _actionCreator.updateShortcode)(props.path.pop()));
        }
    }
};
var prevItem = '',
    hoverStart = '';
var dropSpec = {
    hover: function hover(props, monitor, component) {

var shouldOpen = false;
        if (monitor.isOver({ shallow: true })) {
            prevItem = prevItem || props.path;

if (Immutable.is(prevItem, props.path)) {
                hoverStart = hoverStart || Date.now();
                var timer = Date.now() - hoverStart;
                if (parseInt(timer) > 300) {
                    shouldOpen = true;
                }
            } else {
                hoverStart = '';
                prevItem = '';
            }
        }
        var draggedModulePath = monitor.getItem().path,
            hoveredModulePath = props.path,
            draggedModuleName = monitor.getItem().module.get('name'),
            hoveredModuleName = props.module.get('name'),
            tempDragModulePath = draggedModulePath;

if (props.builderMode !== 'header_builder') {
            if ([3, 5].indexOf(draggedModulePath.size) > -1) {
                if (!Immutable.is(hoveredModulePath.pop(), draggedModulePath.pop())) {
                    return;
                }
            }
        } else {
            if ([2, 4, 6].indexOf(draggedModulePath.size) > -1) {
                if (!Immutable.is(hoveredModulePath.pop(), draggedModulePath.pop())) {
                    return;
                }
            }
        }

if (draggedModulePath.size === 6 && hoveredModulePath.size <= 4) {

if (hoveredModuleName === 'tatsu_inner_row') {
                var hoveredItemOffset = (0, _reactDom.findDOMNode)(component).getBoundingClientRect(),
                    hoveredItemMiddle = (hoveredItemOffset.right - hoveredItemOffset.left) / 2,
                    //Finding the center of the hovered section ( in x axis )
                draggedItemOffset = monitor.getClientOffset(),
                    distanceFromHoveredItemLeft = draggedItemOffset.x - hoveredItemOffset.left,
                    distanceFromHoveredItemTop = draggedItemOffset.y - hoveredItemOffset.top; //Calculating the distance between draggedSection's top and hovered section's top

if (distanceFromHoveredItemLeft > hoveredItemMiddle && distanceFromHoveredItemTop > 0 && distanceFromHoveredItemTop < 35) {
                    //when hovered in the right
                    tempDragModulePath = draggedModulePath.slice(0, -2);
                }
            } else {
                tempDragModulePath = draggedModulePath.slice(0, -2);
            }
        }

if (draggedModulePath.size === 4 && (hoveredModulePath.size > 4 || hoveredModuleName === 'tatsu_inner_row') && 'tatsu_inner_row' !== draggedModuleName) {

if (hoveredModuleName === 'tatsu_inner_row') {
                var _hoveredItemOffset = (0, _reactDom.findDOMNode)(component).getBoundingClientRect(),
                    _hoveredItemMiddle = (_hoveredItemOffset.right - _hoveredItemOffset.left) / 2,
                    //Finding the center of the hovered section ( in x axis )
                _draggedItemOffset = monitor.getClientOffset(),
                    _distanceFromHoveredItemLeft = _draggedItemOffset.x - _hoveredItemOffset.left,
                    _distanceFromHoveredItemTop = _draggedItemOffset.y - _hoveredItemOffset.top; //Calculating the distance between draggedSection's top and hovered section's top

if (_distanceFromHoveredItemLeft < _hoveredItemMiddle && _distanceFromHoveredItemTop > 0 && _distanceFromHoveredItemTop < 35) {
                    //when hovered in the left
                    tempDragModulePath = draggedModulePath.push('x', 'x');
                }
            } else {
                tempDragModulePath = draggedModulePath.push('x', 'x');
            }
        }

if (Immutable.is(hoveredModulePath, draggedModulePath)) {
            return;
        } else if (hoveredModulePath.size != tempDragModulePath.size) {
            if (hoveredModulePath.size === 1 && !props.module.get('inner').size) {
                _reducer2.default.dispatch((0, _actionCreator.addModule)(hoveredModulePath, 'tatsu_row', 'push'));
                return;
            }

if (tempDragModulePath.size > hoveredModulePath.size) {
                if (props.module.get('inner') && 0 < props.module.get('inner').size && !props.open) {
                    shouldOpen && props.toggleState(props.open);
                } else if (0 == props.module.get('inner').size) {
                    var newPath = hoveredModulePath.push(0);
                    monitor.getItem().path = newPath;
                    _reducer2.default.dispatch({ type: 'REORDER_NEW', sourcePath: draggedModulePath, targetPath: (0, _getDropTargetPath2.default)(draggedModulePath, newPath) });
                    var currentDocument = document.getElementById('tatsu-preview').contentDocument,
                        requiredNode = currentDocument.getElementsByClassName('be-pb-observer-' + monitor.getItem().module.get('id'))[0];
                    if (requiredNode != null) {
                        if (requiredNode.getBoundingClientRect().top > window.innerHeight - 100 || requiredNode.getBoundingClientRect().top < 0) {
                            (0, _scrollToSelectedNode2.default)(requiredNode);
                        }
                    }
                }
                return;
            }
        } else {
            if (!Immutable.is(hoveredModulePath.slice(0, -1), draggedModulePath.slice(0, -1))) {
                var temp = hoveredModulePath.set(hoveredModulePath.size - 1, 0),
                    _newPath = (0, _getDropTargetPath2.default)(draggedModulePath, temp);
                monitor.getItem().path = _newPath;
                _reducer2.default.dispatch({ type: 'REORDER_NEW', sourcePath: draggedModulePath, targetPath: _newPath });
                var currentDocument = document.getElementById('tatsu-preview').contentDocument,
                    requiredNode = currentDocument.getElementsByClassName('be-pb-observer-' + monitor.getItem().module.get('id'))[0];
                if (requiredNode != null) {
                    if (requiredNode.getBoundingClientRect().top > window.innerHeight - 100 || requiredNode.getBoundingClientRect().top < 0) {
                        (0, _scrollToSelectedNode2.default)(requiredNode);
                    }
                }
            } else {
                var _hoveredItemOffset2 = (0, _reactDom.findDOMNode)(component).getBoundingClientRect(),
                    _hoveredItemMiddle2 = (_hoveredItemOffset2.bottom - _hoveredItemOffset2.top) / 2,
                    //Finding the center of the hovered section ( in y axis )
                _draggedItemOffset2 = monitor.getClientOffset(),
                    dragIndex = draggedModulePath.get(draggedModulePath.size - 1),
                    hoverIndex = hoveredModulePath.get(hoveredModulePath.size - 1),
                    _distanceFromHoveredItemTop2 = _draggedItemOffset2.y - _hoveredItemOffset2.top; //Calculating the distance between draggedSection's top and hovered section's top
                if (dragIndex > hoverIndex && _distanceFromHoveredItemTop2 > _hoveredItemMiddle2) {
                    //If the dragged Section's index is > hovered Section's index, then it means that the dragged Section is moving upwards!!! So distanceFromHoveredItemTop will be greater in the beginning and we don't have to do fire 'REORDER' until the distanceFromHoveredItemTop is < hoveredItemMiddle!!
                    return;
                }
                if (dragIndex < hoverIndex && _distanceFromHoveredItemTop2 < _hoveredItemMiddle2) {
                    //Similarly, if the dragged Section's index is < hovered Section's index, it implies that dragged Section is moving downwards and we shouldn't fire 'REORDER' until the distanceFromHoveredItemTop > hoveredItemMiddle!!!
                    return;
                }
                monitor.getItem().path = hoveredModulePath;
                _reducer2.default.dispatch({ type: 'REORDER_NEW', sourcePath: draggedModulePath, targetPath: (0, _getDropTargetPath2.default)(draggedModulePath, hoveredModulePath) });

};
}
function dropTargetCollect(connect, monitor) {
    return {
        connectDropTarget: connect.dropTarget()
    };
}

var BirdsEyeViewBlock = function (_React$Component) {
    _inherits(BirdsEyeViewBlock, _React$Component);

function BirdsEyeViewBlock() {
        _classCallCheck(this, BirdsEyeViewBlock);

var _this = _possibleConstructorReturn(this, (BirdsEyeViewBlock.__proto__ || Object.getPrototypeOf(BirdsEyeViewBlock)).call(this));

_this.state = { isRenameActive: false,
            renameValue: '' };
        return _this;
    }

_createClass(BirdsEyeViewBlock, [{
        key: 'handleMenuItemClick',
        value: function handleMenuItemClick(e) {

var value = e.key,
                path = this.props.path,
                moduleName = this.props.module.get('name');

switch (value) {
                case "Duplicate":
                    _reducer2.default.dispatch((0, _actionCreator.duplicate)(path, moduleName));
                    break;
                case "Delete":
                    _reducer2.default.dispatch((0, _actionCreator.deleteModule)(path, moduleName));
                    break;
                case 'Rename':
                    this.setState({ isRenameActive: true });
                    break;
                case 'Save As Template':
                    var drawerMeta = Immutable.Map({
                        action: 'save',
                        saveType: 'sections',
                        path: path
                    });
                    _reducer2.default.dispatch((0, _actionCreator.openDrawer)('template', drawerMeta));
                    break;
                case 'Edit':
                    _reducer2.default.dispatch((0, _actionCreator.setSelection)(path, 'single'));

var currentDocument = document.getElementById('tatsu-preview').contentDocument,
                        requiredNode = currentDocument.getElementsByClassName('be-pb-observer-' + this.props.module.get('id'))[0];
                    if (requiredNode != null) {
                        if (requiredNode.getBoundingClientRect().top > window.innerHeight - 100 || requiredNode.getBoundingClientRect().top < 0) {
                            (0, _scrollToSelectedNode2.default)(requiredNode);
                        }
                    }

break;
                case 'Add Section Above':
                    _reducer2.default.dispatch((0, _actionCreator.addModule)(path, 'tatsu_section', 'insert', 'top'));
                    break;
                case 'Add Section Below':
                    _reducer2.default.dispatch((0, _actionCreator.addModule)(path, 'tatsu_section', 'insert', 'bottom'));
                    break;
                default:
                    break;

}
        }
    }, {
        key: 'keyPressHandler',
        value: function keyPressHandler(e) {
            if (e.keyCode === 13) {
                this.setState({ renameValue: e.target.value,
                    isRenameActive: false });
                _reducer2.default.dispatch((0, _actionCreator.changeTitle)(this.props.path, e.target.value));
            } else if (e.keyCode === 27) {
                this.setState({ isRenameActive: false });
            }
        }
    }, {
        key: 'renameBlurHandler',
        value: function renameBlurHandler() {
            this.setState({ isRenameActive: false });
            _reducer2.default.dispatch((0, _actionCreator.changeTitle)(this.props.path, this.refs.sectionRename.value));
        }
    }, {
        key: 'handleSingleClick',
        value: function handleSingleClick() {
            var currentDocument = document.getElementById('tatsu-preview').contentDocument,
                requiredNode = currentDocument.getElementsByClassName('be-pb-observer-' + this.props.module.get('id'))[0];

if (requiredNode != null) {
                if (requiredNode.getBoundingClientRect().top > window.innerHeight - 100 || requiredNode.getBoundingClientRect().top < 100) {
                    (0, _scrollToSelectedNode2.default)(requiredNode);
                }
            }
            this.props.toggleState(this.props.open);
        }
    }, {
        key: 'handleCardDoubleClick',
        value: function handleCardDoubleClick() {
            _reducer2.default.dispatch((0, _actionCreator.setSelection)(this.props.path, 'single'));

var currentDocument = document.getElementById('tatsu-preview').contentDocument,
                requiredNode = currentDocument.getElementsByClassName('be-pb-observer-' + this.props.module.get('id'))[0];
            if (requiredNode != null) {
                if (requiredNode.getBoundingClientRect().top > window.innerHeight - 100 || requiredNode.getBoundingClientRect().top < 0) {
                    (0, _scrollToSelectedNode2.default)(requiredNode);
                }
            }

this.props.toggleState(this.props.open);
        }
    }, {
        key: 'handleMouseEnter',
        value: function handleMouseEnter() {

var title = this.props.moduleOptions.getIn([this.props.module.get('name'), 'title']);
            var messageData = 'hover_set,' + this.props.module.get('id') + ',' + title;
            document.getElementById('tatsu-preview').contentWindow.postMessage(messageData, '*');
        }
    }, {
        key: 'handleMouseLeave',
        value: function handleMouseLeave() {

document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
        }
    }, {
        key: 'render',
        value: function render() {
            var _props = this.props,
                connectDragSource = _props.connectDragSource,
                connectDropTarget = _props.connectDropTarget,
                isDragging = _props.isDragging,
                toggleState = _props.toggleState,
                openClassName = this.props.open && this.props.module.get('inner') && 0 < this.props.module.get('inner').size ? 'be-card-open' : '',
                moduleName = this.props.module.get('name'),
                curSltdClassName = this.props.selectionState && Immutable.is(this.props.path, this.props.selectionState.get('selectionList').getIn([0, 'path'])) ? 'be-card-selected' : '';

var left = -59,
                menuItems = _uiConstants.birdsEyeViewMenu.base,
                hiddenIconVisiblity = 'hidden',
                blockTitle = this.props.moduleOptions.getIn([moduleName, 'title']) || moduleName;

if (moduleName === 'tatsu_section') {
                menuItems = menuItems.concat(_uiConstants.birdsEyeViewMenu.section);
                left = -104;

blockTitle = this.props.module.getIn(['atts', 'section_title']) || blockTitle;
            } else if (moduleName === 'tatsu_column' || moduleName === 'tatsu_inner_column') {
                menuItems = menuItems.filter(function (item) {
                    return item !== 'Duplicate';
                });
            }

var moduleHint = this.props.moduleOptions.getIn([moduleName, 'hint']),
                hintContent = this.props.module.getIn(['atts', moduleHint]);

if (moduleHint && hintContent) {
                if (typeof hintContent === 'string') {
                    var blockTitleArray = [];

if (moduleName === 'tatsu_icon') {
                        blockTitleArray = [React.createElement(
                            'span',
                            null,
                            blockTitle
                        ), " - ", React.createElement('i', { className: hintContent })];
                    } else {
                        blockTitle = blockTitle + " - " + hintContent;
                        var parsedBlockTitle = jQuery.parseHTML(blockTitle);

parsedBlockTitle.forEach(function (element) {
                            if (element.innerText) {
                                blockTitleArray.push(element.innerText);
                            } else {
                                blockTitleArray.push(element.textContent);
                            }
                        });
                    }
                    blockTitle = blockTitleArray;
                }
            }

menuItems = menuItems.map(function (item, index) {
                return React.createElement(
                    Item,
                    { key: item },
                    ' ',
                    item,
                    ' '
                );
            });

if (this.props.module.getIn(['atts', 'hide_in']) && this.props.module.getIn(['atts', 'hide_in']).indexOf(this.props.targetDisplay) > -1) {
                hiddenIconVisiblity = 'visible';
            }

return connectDragSource(connectDropTarget(React.createElement(
                'div',
                { style: jQuery.extend({}, { opacity: isDragging ? '0.3' : null }, this.props.isLayoutPanel ? { padding: '0 10px' } : { marginLeft: 0 < this.props.path.size - 1 ? '15px' : null }), className: 'be-birdseye-view-block ' + openClassName + ' ' + curSltdClassName },
                React.createElement(
                    'div',
                    { className: 'be-birdseye-view-block-title-wrap', onDoubleClick: this.handleCardDoubleClick.bind(this), onClick: this.props.isLayoutPanel ? this.handleCardDoubleClick.bind(this) : this.handleSingleClick.bind(this), onMouseEnter: this.handleMouseEnter.bind(this), onMouseLeave: this.handleMouseLeave.bind(this) },
                    this.props.moduleOptions.getIn([this.props.module.get('name'), 'child_module']) && !this.props.isLayoutPanel && React.createElement(
                        'div',
                        { className: 'be-ui-arrow-icon' },
                        React.createElement(
                            'svg',
                            { xmlns: 'http://www.w3.org/2000/svg', className: 'tatsu-svg-icon', xmlnsXlink: 'http://www.w3.org/1999/xlink', version: '1.1', x: '0px', y: '0px', viewBox: '0 0 100 125', enableBackground: 'new 0 0 100 100', xmlSpace: 'preserve' },
                            React.createElement(
                                'g',
                                null,
                                React.createElement('path', { d: 'M85.256,37.404c-0.602-0.721-1.449-1.23-2.316-1.27L82.945,36H17.103l0.01,0.137c-0.886,0.027-1.757,0.469-2.369,1.203   c-1.135,1.356-0.951,3.413,0.408,4.545l32.795,27.354c0.596,0.497,1.324,0.753,2.053,0.753c0.73,0,1.459-0.244,2.055-0.741   l32.793-27.336C86.207,40.783,86.391,38.761,85.256,37.404z' })
                            )
                        )
                    ),
                    React.createElement(
                        'div',
                        { className: 'be-birdseye-view-block-title' },
                        this.state.isRenameActive ? React.createElement('input', { onKeyDown: this.keyPressHandler.bind(this), ref: 'sectionRename', placeholder: 'Give it a name', onBlur: this.renameBlurHandler.bind(this), autoFocus: true, onClick: function onClick(e) {
                                return e.stopPropagation();
                            } }) : blockTitle
                    ),
                    React.createElement(
                        _tooltip2.default,
                        { title: 'Hidden in ' + this.props.targetDisplay + ' view' },
                        React.createElement(
                            'div',
                            { className: 'be-birdseye-view-block-visiblity', style: { visibility: hiddenIconVisiblity } },
                            React.createElement(
                                'svg',
                                { width: '14', height: '14', viewBox: '0 -3 24 24' },
                                React.createElement('path', { fill: 'none', d: 'M0 0h24v24H0V0zm0 0h24v24H0V0zm0 0h24v24H0V0zm0 0h24v24H0V0z' }),
                                React.createElement('path', { d: 'M12 6c3.79 0 7.17 2.13 8.82 5.5-.59 1.22-1.42 2.27-2.41 3.12l1.41 1.41c1.39-1.23 2.49-2.77 3.18-4.53C21.27 7.11 17 4 12 4c-1.27 0-2.49.2-3.64.57l1.65 1.65C10.66 6.09 11.32 6 12 6zm-1.07 1.14L13 9.21c.57.25 1.03.71 1.28 1.28l2.07 2.07c.08-.34.14-.7.14-1.07C16.5 9.01 14.48 7 12 7c-.37 0-.72.05-1.07.14zM2.01 3.87l2.68 2.68C3.06 7.83 1.77 9.53 1 11.5 2.73 15.89 7 19 12 19c1.52 0 2.98-.29 4.32-.82l3.42 3.42 1.41-1.41L3.42 2.45 2.01 3.87zm7.5 7.5l2.61 2.61c-.04.01-.08.02-.12.02-1.38 0-2.5-1.12-2.5-2.5 0-.05.01-.08.01-.13zm-3.4-3.4l1.75 1.75c-.23.55-.36 1.15-.36 1.78 0 2.48 2.02 4.5 4.5 4.5.63 0 1.23-.13 1.77-.36l.98.98c-.88.24-1.8.38-2.75.38-3.79 0-7.17-2.13-8.82-5.5.7-1.43 1.72-2.61 2.93-3.53z' })
                            )
                        )
                    ),
                    React.createElement(
                        _popoverMenu2.default,
                        { className: 'be-birds-eye-view-menu', icon: 'ellipsis', width: 'auto', positionAdjustment: { top: 26, left: left }, wrapWithinViewport: true },
                        React.createElement(
                            _menu2.default,
                            { mode: 'vertical', style: { width: '100%' }, selectable: false, onClick: this.handleMenuItemClick.bind(this), className: 'be-ui-component be-menu' },
                            menuItems
                        )
                    )
                ),
                this.props.open && React.createElement(_birdsEyeViewList2.default, { openSelectedPath: this.props.openSelectedPath, moduleOptions: this.props.moduleOptions, moduleChildren: this.props.module.get('inner'), path: this.props.path, module: this.props.module, selectionState: this.props.selectionState, builderMode: this.props.builderMode, targetDisplay: this.props.targetDisplay })
            )));
        }
    }]);

return BirdsEyeViewBlock;
}(React.Component);

exports.default = (0, _flow2.default)((0, _reactDnd.DragSource)(_dndConstants.birdsEyeView.module, dragSpec, dragSourceCollect), (0, _reactDnd.DropTarget)(_dndConstants.birdsEyeView.module, dropSpec, dropTargetCollect))(BirdsEyeViewBlock);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4), __webpack_require__(3), __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 671 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _birdsEyeViewBlock = __webpack_require__(670);

var _birdsEyeViewBlock2 = _interopRequireDefault(_birdsEyeViewBlock);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var BirdsEyeViewBlockWrapper = function (_React$Component) {
    _inherits(BirdsEyeViewBlockWrapper, _React$Component);

function BirdsEyeViewBlockWrapper(props) {
        _classCallCheck(this, BirdsEyeViewBlockWrapper);

var _this = _possibleConstructorReturn(this, (BirdsEyeViewBlockWrapper.__proto__ || Object.getPrototypeOf(BirdsEyeViewBlockWrapper)).call(this, props));

_this.state = {
            open: false
        };

_this.openSelectedPath = _this.props.openSelectedPath;

_this.toggleState = _this.toggleState.bind(_this);
        return _this;
    }

_createClass(BirdsEyeViewBlockWrapper, [{
        key: 'toggleState',
        value: function toggleState(currentState) {
            //  let currentState = this.state.open;
            if (currentState != null) {
                this.setState({
                    open: !currentState
                });
            } else {
                this.setState({
                    open: !this.state.open
                });
            }
        }
    }, {
        key: 'componentWillMount',
        value: function componentWillMount() {

if (this.openSelectedPath && this.props.selectionState && this.props.selectionState.size) {
                var selectedPath = this.props.selectionState.get('selectionList').getIn([0, 'path']),
                    thisBlockPath = this.props.path,
                    tempArray = Immutable.List([]);

if (selectedPath && selectedPath.size > thisBlockPath.size) {
                    tempArray = selectedPath.slice(0, thisBlockPath.size);
                    if (Immutable.is(tempArray, thisBlockPath)) {
                        this.setState({ open: true });
                    } else {
                        this.setState({ open: false });
                    }
                } else {
                    this.setState({ open: false });
                }
            } else {
                this.setState({ open: false });
            }
        }
    }, {
        key: 'componentDidMount',
        value: function componentDidMount() {
            this.openSelectedPath = false;
        }
    }, {
        key: 'render',
        value: function render() {
            var _props = this.props,
                module = _props.module,
                moduleOptions = _props.moduleOptions,
                path = _props.path,
                parentModule = _props.parentModule;

return React.createElement(_birdsEyeViewBlock2.default, {
                toggleState: this.toggleState,
                module: module,
                parentModule: parentModule,
                path: path,
                open: this.state.open,
                moduleOptions: moduleOptions,
                openSelectedPath: this.openSelectedPath,
                selectionState: this.props.selectionState,
                isLayoutPanel: this.props.isLayoutPanel,
                builderMode: this.props.builderMode,
                targetDisplay: this.props.targetDisplay
            });
        }
    }]);

return BirdsEyeViewBlockWrapper;
}(React.Component);

exports.default = BirdsEyeViewBlockWrapper;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 672 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable) {

var dataConstant = __webpack_require__(362),
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    ColumnSwitch = __webpack_require__(215),
    ColumnSplitRenderer = __webpack_require__(673),
    parentComponentFinder = __webpack_require__(98);

__webpack_require__(911);

var ColumnElement = React.createClass({
    displayName: 'ColumnElement',

propTypes: {
        target: mapChecker,
        path: listChecker,
        moduleOptions: mapChecker
    },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var result = true;
        result = !(Immutable.is(this.props.target, nextProps.target) && Immutable.is(this.props.path, nextProps.path));
        return result;
    },

componentDidMount: function componentDidMount() {

document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    },

renderColumnSwitch: function renderColumnSwitch(path, targetLayout) {

var parentComponent = parentComponentFinder(path, 'current');

if (!(this.props.builderMode === 'header_builder' && parentComponent.get('name') === 'tatsu_hamburger_menu')) {
            return React.createElement(
                'div',
                null,
                React.createElement(
                    'div',
                    { className: 'be-pb-column-text' },
                    dataConstant.columnSwitchConstant
                ),
                React.createElement(ColumnSwitch, { path: path, targetLayout: targetLayout, path: path })
            );
        }
    },

render: function render() {
        var targetLayout = this.props.target.getIn(['atts', 'layout']),
            moduleOptions = this.props.moduleOptions,
            path = this.props.path,
            children = this.props.target.get('inner');

return React.createElement(
            'div',
            { className: 'be-pb-module' },
            this.renderColumnSwitch(path, targetLayout),
            React.createElement(
                'div',
                { className: 'be-pb-column-text' },
                dataConstant.columnLayoutConstant
            ),
            React.createElement(ColumnSplitRenderer, { moduleOptions: moduleOptions, targetLayout: targetLayout, row: this.props.target, children: children, path: path })
        );
    }

});
module.exports = ColumnElement;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3)))

/***/ }),
/* 673 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var DraggableModuleCard = __webpack_require__(674),
    listChecker = __webpack_require__(16).listChecker,
    isEmpty = __webpack_require__(5);
var ColumnSplitRenderer = React.createClass({
    displayName: 'ColumnSplitRenderer',

propTypes: {
        children: listChecker,
        path: listChecker
    },
    render: function render() {
        var children = this.props.children,
            moduleOptions = this.props.moduleOptions,
            row = this.props.row,
            rowPath = this.props.path,
            targetLayout = this.props.targetLayout;
        return React.createElement(
            'div',
            { className: 'be-pb-column-split-renderer', style: { width: '100%', minHeight: '40px', textAlign: 'center' } },
            children.map(function (column, index) {
                var columnWidth = column.getIn(['atts', 'layout']),
                    columnName = column.get('name'),
                    columnWidth = columnWidth.split("/"),
                    columnPath = rowPath.push(index);
                columnWidth = 100 / columnWidth[1] * columnWidth[0] - 4 + "%";
                return React.createElement(DraggableModuleCard, { parent: row, moduleOptions: moduleOptions, key: column.get('id'), module: column, columnWidth: columnWidth, path: columnPath, name: columnName });
            })
        );
    }
});
module.exports = ColumnSplitRenderer;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 674 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var findDOMNode = __webpack_require__(7).findDOMNode,
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    Immutable = __webpack_require__(3),
    updateShortcode = __webpack_require__(2).updateShortcode,
    DragSource = __webpack_require__(37).DragSource,
    dndPageScroll = __webpack_require__(121),
    DropTarget = __webpack_require__(37).DropTarget,
    setSelection = __webpack_require__(2).setSelection,
    flow = __webpack_require__(60),
    dndScope = __webpack_require__(79).sortableDnDConstant,
    store = __webpack_require__(11),
    encodePath = __webpack_require__(43).encodePath,
    routeResolve = __webpack_require__(33),
    parentComponentFinder = __webpack_require__(98),
    browserHistory = __webpack_require__(40).browserHistory;
var dragSpecification = {

beginDrag: function beginDrag(props, monitor, component) {

var name = props.module.get('name'),
        type = props.moduleOptions.getIn([name, 'type']);
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    dndPageScroll.showDragScroll(findDOMNode(component).className);
    return {
      path: props.path,
      type: type,
      parent: props.parent,
      shouldTrigger: false
    };
  },
  endDrag: function endDrag(props, monitor) {

var parentName = props.parent.get('name'),
        draggedModulePath = monitor.getItem().path,
        parentType = props.moduleOptions.getIn([parentName, 'type']),
        parentIsBuiltIn = props.moduleOptions.getIn([parentName, 'is_built_in']);
    dndPageScroll.hideDragScroll();
    if (('sub_module' === monitor.getItem().type || 'multi' === parentType) && monitor.getItem().shouldTrigger && !parentIsBuiltIn) {
      store.dispatch(updateShortcode(draggedModulePath.pop()));
    }
  }

};
var dropSpecification = {

hover: function hover(props, monitor, component) {

};
function dragSourceCollect(connect, monitor) {
  return {
    connectDragSource: connect.dragSource(),
    isDragging: monitor.isDragging()

};
}
function dropTargetCollect(connect, monitor) {
  return {
    connectDropTarget: connect.dropTarget(),
    isOver: monitor.isOver(),
    canDrop: monitor.canDrop()
  };
}
var DraggableModuleCard = React.createClass({
  displayName: 'DraggableModuleCard',

propTypes: {
    module: mapChecker,
    path: listChecker,
    name: React.PropTypes.string.isRequired,
    connectDragSource: React.PropTypes.func.isRequired,
    connectDropTarget: React.PropTypes.func.isRequired,
    isOver: React.PropTypes.bool.isRequired,
    isDragging: React.PropTypes.bool.isRequired,
    canDrop: React.PropTypes.bool.isRequired
  },

handleEdit: function handleEdit(path, event) {

var parentRoute,
        moduleName = this.props.module.get('name'),
        serializedPath;
    store.dispatch(setSelection(path, 'single'));
  },

routeHandler: function routeHandler(path) {

var serializedPath = encodePath(path.toJS().toString()),
        parentRoute = routeResolve(window.location.pathname);
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
    //browserHistory.push( parentRoute + 'layoutManager/'+serializedPath);
    store.dispatch(setSelection(path, 'single'));
  },

handleMouseEnter: function handleMouseEnter(title, type) {

var parentType = this.props.moduleOptions.getIn([this.props.parent.get('name'), 'type']);
    if ('sub_module' === type || 'multi' === parentType) {
      return;
    }
    var messageData = 'hover_set,' + this.props.module.get('id') + ',' + title;
    document.getElementById('tatsu-preview').contentWindow.postMessage(messageData, '*');
  },

handleMouseLeave: function handleMouseLeave(type) {

var parentType = this.props.moduleOptions.getIn([this.props.parent.get('name'), 'type']);
    if ('sub_module' === type || 'multi' === parentType) {
      return;
    }
    document.getElementById('tatsu-preview').contentWindow.postMessage('hover_reset', '*');
  },

cardRenderer: function cardRenderer(type, title, path, module, style) {

switch (type) {

//need to be refractored based on name instead of type
      case 'core':
        var parentComponent = parentComponentFinder(path);
        if (parentComponent.get('name') === 'tatsu_hamburger_menu') {
          style.width = '100%';
          style.marginBottom = '10px';
        } else {
          style.width = this.props.columnWidth;
        }
        return React.createElement(
          'div',
          { className: 'be-pb-column-split', style: style, onClick: this.routeHandler.bind(null, path), onMouseEnter: this.handleMouseEnter.bind(null, title), onMouseLeave: this.handleMouseLeave },
          path.get(path.size - 1) + 1
        );

case 'single':
      case 'sub_module':
        return React.createElement(
          'div',
          { style: style, className: 'be-pb-module-card', onMouseEnter: this.handleMouseEnter.bind(null, title, type), onMouseLeave: this.handleMouseLeave.bind(null, type) },
          React.createElement(
            'div',
            { className: 'be-pb-module-card-title', onClick: this.handleEdit.bind(null, path) },
            title
          )
        );

case 'multi':
      case 'innerRow':
        return React.createElement(
          'div',
          { style: style, className: 'be-pb-module-card', onMouseEnter: this.handleMouseEnter.bind(null, title), onMouseLeave: this.handleMouseLeave },
          React.createElement(
            'div',
            { className: 'be-pb-module-card-title', onClick: this.handleEdit.bind(null, path) },
            title
          )
        );

default:
        return React.createElement('div', null);

}
  },
  render: function render() {
    var path = this.props.path,
        module = this.props.module,
        type = module.get('type'),
        title = typeof module.get('title') != 'undefined' ? module.get('title') : store.getState().moduleOptions.getIn([module.get('name'), 'title']) || 'Module',
        connectDragSource = this.props.connectDragSource,
        connectDropTarget = this.props.connectDropTarget,
        isDragging = this.props.isDragging,
        canDrop = this.props.canDrop,
        isOver = this.props.isOver,
        style = { opacity: isDragging ? 0 : 1 },
        currentModuleCard = this.cardRenderer(type, title, path, module, style); // cardRenderer decides the module to be rendered!!!
    return connectDragSource(connectDropTarget(currentModuleCard));
  }
});
module.exports = flow(DragSource(dndScope.module, dragSpecification, dragSourceCollect), DropTarget(dndScope.module, dropSpecification, dropTargetCollect))(DraggableModuleCard);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 675 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _reactCodemirror = __webpack_require__(1167);

var _infoBox = __webpack_require__(638);

var _infoBox2 = _interopRequireDefault(_infoBox);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var HeaderGlobalSettings = __webpack_require__(676),
    store = __webpack_require__(11),
    BeText = __webpack_require__(356).default,
    resetSelection = __webpack_require__(2).resetSelection,
    triggerScript = __webpack_require__(242),
    BeSelect = __webpack_require__(93).default;

__webpack_require__(791);
__webpack_require__(790);
__webpack_require__(1454);
if ('dark' === tatsuConfig.theme) {
    __webpack_require__(909);
} else {
    __webpack_require__(910);
}

var GlobalSettings = React.createClass({
    displayName: 'GlobalSettings',

postStatusChange: function postStatusChange(value) {
        store.dispatch({ type: 'UPDATE_POST_STATUS', post_status: value });
    },
    postNameChange: function postNameChange(value) {
        store.dispatch({ type: 'UPDATE_POST_NAME', post_name: value });
    },

componentDidMount: function componentDidMount() {
        store.dispatch(resetSelection());
    },
    updateJsCode: function updateJsCode(editor, data, newCode) {
        var iframeTarget = document.getElementById('tatsu-preview');
        store.dispatch({ type: 'UPDATE_CUSTOM_JS', customJs: newCode });
    },
    updateCssCode: function updateCssCode(editor, data, newCode) {
        var iframeTarget = document.getElementById('tatsu-preview');
        if (null !== iframeTarget) {
            var tatsuPostStyle = iframeTarget.contentDocument.getElementById('tatsu-post-style');
            if (null !== tatsuPostStyle) {
                tatsuPostStyle.textContent = newCode;
            } else {
                var styleTag = document.createElement('style');
                styleTag.setAttribute('id', 'tatsu-post-style');
                styleTag.textContent = newCode;
                iframeTarget.contentDocument.getElementsByTagName('head')[0].append(styleTag);
            }
        }
        store.dispatch({ type: 'UPDATE_CUSTOM_CSS', customCss: newCode });
    },
    render: function render() {

var postStatusOptions,
            options = {
            lineNumbers: true,
            lineWrapping: true,
            theme: 'dark' === tatsuConfig.theme ? 'tatsu-dark' : 'tatsu-light'
        };
        if ('1' == tatsuConfig.publishable) {
            postStatusOptions = {
                publish: 'Published',
                private: 'Private',
                pending: 'Pending Review',
                draft: 'Draft'
            };
        } else {
            postStatusOptions = {
                pending: 'Pending Review',
                draft: 'Draft'
            };
        }
        return React.createElement(
            'div',
            { className: 'tatsu-global-setting-panel', style: { 'height': '100%' } },
            this.props.builderMode === 'header_builder' && React.createElement(HeaderGlobalSettings, {
                builderMode: this.props.builderMode,
                pageContent: this.props.pageContent
            }),
            this.props.builderMode !== 'header_builder' && [React.createElement(
                'div',
                { className: 'be-pb-field-wrap' },
                'Post Name :',
                React.createElement(BeText, {
                    value: this.props.globalPostDetails.post_name,
                    onChange: this.postNameChange
                })
            ), React.createElement(
                'div',
                { className: 'be-pb-field-wrap' },
                'Post Status :',
                React.createElement(BeSelect, {
                    options: postStatusOptions,
                    value: this.props.globalPostDetails.post_status,
                    onChange: this.postStatusChange
                })
            )],
            React.createElement(
                'div',
                { className: 'tatsu-code-editors' },
                React.createElement(
                    'div',
                    { className: 'tatsu-code-editor tatsu-code-editor-css be-pb-field-wrap' },
                    'Custom Css',
                    React.createElement(_reactCodemirror.Controlled, { value: this.props.globalPostDetails.customCss, onBeforeChange: this.updateCssCode, options: jQuery.extend({}, options, { mode: 'css' }) })
                ),
                React.createElement(
                    'div',
                    { className: 'tatsu-code-editor tatsu-code-editor-js be-pb-field-wrap' },
                    'Custom Javascript',
                    React.createElement(
                        _infoBox2.default,
                        { type: 'warning' },
                        'Scripts added in the custom js area will not be visible inside the builder.'
                    ),
                    React.createElement(_reactCodemirror.Controlled, { value: this.props.globalPostDetails.customJs, onBeforeChange: this.updateJsCode, options: jQuery.extend({}, options, { mode: 'javascript' }) })
                )
            )
        );
    }
});

exports.default = GlobalSettings;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4)))

/***/ }),
/* 676 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var _switch = __webpack_require__(209);

var _switch2 = _interopRequireDefault(_switch);

var _checkbox = __webpack_require__(204);

var _checkbox2 = _interopRequireDefault(_checkbox);

var _select = __webpack_require__(65);

var _select2 = _interopRequireDefault(_select);

__webpack_require__(210);

__webpack_require__(205);

__webpack_require__(66);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var store = __webpack_require__(11),
    BeSelect = __webpack_require__(93).default;

var Option = _select2.default.Option;

var HeaderGlobalSettings = React.createClass({
  displayName: 'HeaderGlobalSettings',

editSetting: function editSetting(setting, checked) {
    store.dispatch({
      type: "EDIT_GLOBAL_SETTING",
      settingKey: setting.id,
      settingValue: checked,
      builderMode: this.props.builderMode
    });
  },

editSchemeSetting: function editSchemeSetting(setting, value, isInput) {
    store.dispatch({
      type: "EDIT_GLOBAL_SETTING",
      settingKey: setting.id,
      settingValue: value,
      builderMode: this.props.builderMode
    });
  },

editEnablers: function editEnablers(setting, value, event) {
    var valueArray = setting.value,
        isInputChecked = event.target.checked;
    if (!isInputChecked) {
      valueArray.splice(valueArray.indexOf(value), 1);
    } else {
      valueArray.push(value);
    }

store.dispatch({
      type: "EDIT_GLOBAL_SETTING",
      settingKey: setting.id,
      settingValue: valueArray,
      builderMode: this.props.builderMode
    });
  },

stringCapitalize: function stringCapitalize(value) {
    value = value.replace("_", " ");
    return value.charAt(0).toUpperCase() + value.slice(1);
  },

render: function render() {
    var settingsValue = this.props.pageContent.getIn(["present", "settings"]).toJS(),
        enableConfig = tatsuConfig.transparent_header_list,
        settingsConfig = [{
      id: "active_header",
      title: "Active Header",
      value: false
    }, {
      id: "sticky",
      title: "Sticky",
      value: false
    }, {
      id: "smart",
      title: "Smart",
      value: false
    }, {
      id: "transparent",
      title: "Transparent",
      value: false
    }, {
      id: "scheme",
      title: "Color Scheme",
      value: "dark"
    }, {
      id: "archive",
      title: "Archive",
      value: enableConfig.archive
    }, {
      id: "single",
      title: "Single Post",
      value: enableConfig.single
    }, {
      id: "taxonomy",
      title: "Taxonomy",
      value: enableConfig.taxonomy
    }, {
      id: "other",
      title: "Others",
      value: enableConfig.other
    }];

if (!settingsValue.hasOwnProperty("active_header")) {
      if (window.tatsuConfig.active_header) {
        settingsValue.active_header = window.tatsuConfig.post_id === window.tatsuConfig.active_header;
      }
    }

settingsConfig.forEach(function (setting, key) {
      return setting.value = settingsValue.hasOwnProperty(setting.id) ? settingsValue[setting.id] : setting.value;
    });

return React.createElement(
      'ul',
      { className: 'be-editor-field-list' },
      settingsConfig.map(function (setting) {
        if (setting.id === "scheme") {
          if (!settingsValue.transparent) {
            return null;
          } else {
            return React.createElement(
              'li',
              { className: 'be-editor-field-set' },
              React.createElement(
                'div',
                { className: 'be-editor-field be-editor-field-global-inline' },
                setting.title,
                React.createElement(BeSelect, {
                  value: setting.value,
                  onChange: this.editSchemeSetting.bind(null, setting),
                  options: {
                    dark: 'Dark',
                    light: 'Light'
                  }
                })
              )
            );
          }
        } else if (setting.id === "archive" || setting.id === "single" || setting.id === "taxonomy" || setting.id === "other") {
          if (!settingsValue.transparent) {
            return null;
          } else {
            var currentField = setting.id;

return React.createElement(
              'li',
              { className: 'be-editor-field-set' },
              React.createElement(
                'div',
                {
                  className: 'be-editor-field',
                  style: { display: "flex", flexDirection: "column" }
                },
                React.createElement(
                  'div',
                  {
                    className: 'be-editor-field-label',
                    style: { marginBottom: "10px" }
                  },
                  setting.title
                ),
                enableConfig[currentField].map(function (list) {
                  return React.createElement(
                    _checkbox2.default,
                    {
                      style: { marginLeft: 10 },
                      onChange: this.editEnablers.bind(null, setting, list),
                      checked: setting.value.indexOf(list) > -1
                    },
                    this.stringCapitalize(list)
                  );
                }.bind(this))
              )
            );
          }
        } else {
          if (setting.id === "smart" && !settingsValue.sticky) {
            return null;
          } else {
            return React.createElement(
              'li',
              { className: 'be-editor-field-set' },
              React.createElement(
                'div',
                { className: 'be-editor-field-label switch' },
                setting.title
              ),
              React.createElement(
                'div',
                { className: 'be-editor-field be-switch' },
                React.createElement(_switch2.default, {
                  style: { width: "50%" },
                  defaultChecked: setting.value,
                  onChange: this.editSetting.bind(null, setting)
                })
              )
            );
          }
        }
      }.bind(this))
    );
  }
});

module.exports = HeaderGlobalSettings;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 677 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var layoutConstants = __webpack_require__(362);
var HelpText = React.createClass({
  displayName: 'HelpText',

propTypes: {
    moduleName: React.PropTypes.string
  },
  fetchHelptext: function fetchHelptext(name) {
    switch (name) {
      case 'home':
        return layoutConstants.homeConstant;
      case 'EDITOR':
        return layoutConstants.editorConstant;
      case 'miscellaneous':
        return layoutConstants.miscellaneous;
      case 'similar':
        return layoutConstants.similar;
      case 'tatsu_row':
      case 'tatsu_inner_row':
        return layoutConstants.columnConstant;
      case 'moduleListDraggable':
        return layoutConstants.moduleListDraggable;
      case 'moduleListClickable':
        return layoutConstants.moduleListClickable;
      default:
        return false;
    }
  },

render: function render() {
    var targetName = this.props.moduleName,
        helpText = this.fetchHelptext(targetName);
    if (helpText) {
      return React.createElement(
        'div',
        { style: { marginBottom: 'tatsu_row' === targetName ? '70px' : null }, className: 'be-pb-helper-text' },
        helpText
      );
    } else {
      return null;
    }
  }
});
module.exports = HelpText;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 678 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var store = __webpack_require__(11),
    loadSelectedRevision = __webpack_require__(2).loadSelectedRevision,
    store = __webpack_require__(11),
    loadMoreBtn = __webpack_require__(2).loadMoreRevisionData,
    saveData = __webpack_require__(2).saveData;

var Revisions = React.createClass({
  displayName: "Revisions",

revisionBtnClick: function revisionBtnClick(btn) {
    if (btn === "apply") {
      store.dispatch(saveData());
    } else {
      store.dispatch(loadSelectedRevision("current"));
    }
  },

revisionItemClick: function revisionItemClick(revisionId) {
    if (this.props.revisionHelper.selectedRevision !== revisionId) {
      store.dispatch(loadSelectedRevision(revisionId));
    }
  },

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

return this.props.revisionHelper.selectedRevision !== nextProps.revisionHelper.selectedRevision || this.props.revisionHelper.revisionData.revisions[0].key !== nextProps.revisionHelper.revisionData.revisions[0].key || this.props.revisionHelper.revisionData.revisions.length !== nextProps.revisionHelper.revisionData.revisions.length || this.props.revisionHelper.isLoading !== nextProps.revisionHelper.isLoading || this.props.revisionHelper.revisionDataLoading !== nextProps.revisionHelper.revisionDataLoading;
  },

loadMoreClick: function loadMoreClick() {

store.dispatch(loadMoreBtn());
  },

render: function render() {

var revisionList = [];
    var revision_data = this.props.revisionHelper.revisionData,
        currentUserId = "",
        authors = revision_data.authors,
        isMoreItemsLoading = this.props.revisionHelper.revisionDataLoading,
        revisionsAvailable = revision_data.more_items,
        revisionsToDisplay = [].concat(_toConsumableArray(revision_data.revisions));

Object.keys(authors).forEach(function (author) {
      if (authors[author][0] === window.tatsuConfig.current_user) {
        currentUserId = author;
      }
    });

revisionsToDisplay[0] = {
      key: "current",
      post_date: "current version",
      short_date: "",
      author: currentUserId
    };

revisionsToDisplay.forEach(function (revision, index) {
      var isLoading = this.props.revisionHelper.isLoading && this.props.revisionHelper.selectedRevision === revision.key,
          isSelected = !this.props.revisionHelper.isLoading && this.props.revisionHelper.selectedRevision === revision.key;

revisionList.push(React.createElement(
        "div",
        {
          className: "be-pb-revision-item " + (isSelected ? "selected" : isLoading ? "loading" : ""),
          onClick: this.revisionItemClick.bind(this, revision.key)
        },
        React.createElement(
          "div",
          { className: "be-pb-revision-author-img" },
          " ",
          React.createElement("img", { src: revision_data.authors[revision.author][1] })
        ),
        React.createElement(
          "div",
          { className: "be-pb-revision-desc" },
          React.createElement(
            "div",
            { className: "be-pb-revision-author-name" },
            React.createElement(
              "span",
              null,
              window.tatsuConfig.current_user === revision_data.authors[revision.author][0] ? "you" : revision_data.authors[revision.author][0]
            )
          ),
          React.createElement(
            "div",
            { className: "be-pb-revision-date" },
            React.createElement(
              "span",
              null,
              revision.post_date
            ),
            revision.short_date && React.createElement(
              "span",
              null,
              " (",
              revision.short_date,
              ")"
            )
          )
        ),
        React.createElement(
          "div",
          { className: "be-pb-revision-state-icon" },
          isLoading && React.createElement(
            "svg",
            { width: "20", height: "20", viewBox: "0 0 24 24" },
            React.createElement("path", { fill: "none", d: "M0 0h24v24H0V0z" }),
            React.createElement("path", { d: "M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z" })
          ),
          isSelected && React.createElement(
            "svg",
            { width: "20", height: "20", viewBox: "0 0 20 20" },
            React.createElement("path", { fill: "none", d: "M0 0h24v24H0V0z" }),
            React.createElement("path", { d: "M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41L9 16.17z" })
          )
        )
      ));
    }.bind(this));

return React.createElement(
      "div",
      { className: "be-pb-revision" },
      React.createElement(
        "div",
        { className: "be-pb-revision-list" },
        revisionList
      ),
      React.createElement(
        "div",
        { className: "be-pb-revision-loadmore " + (revisionsAvailable ? 'enabled ' : 'disabled ') + (isMoreItemsLoading ? 'loading' : ''), onClick: this.loadMoreClick },
        isMoreItemsLoading ? 'Loading...' : 'Load More'
      ),
      React.createElement(
        "div",
        {
          className: "be-pb-revision-btns " + (["current", ""].indexOf(this.props.revisionHelper.selectedRevision) > -1 ? "disabled" : "")
        },
        React.createElement(
          "div",
          {
            className: "be-pb-revision-btn discard",
            onClick: this.revisionBtnClick.bind(this, "discard")
          },
          "Discard"
        ),
        React.createElement(
          "div",
          {
            className: "be-pb-revision-btn apply",
            onClick: this.revisionBtnClick.bind(this, "apply")
          },
          "Apply"
        )
      )
    );
  }
});

module.exports = Revisions;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 679 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var React = __webpack_require__(0),
    mapChecker = __webpack_require__(16).mapChecker,
    listChecker = __webpack_require__(16).listChecker,
    Immutable = __webpack_require__(3),
    DragSource = __webpack_require__(37).DragSource,
    getPathFromPosition = __webpack_require__(239),
    flow = __webpack_require__(60),
    empty = __webpack_require__(182),
    _addModule = __webpack_require__(2).addModule,
    findDOMNode = ReactDOM.findDOMNode,
    startDrag = __webpack_require__(2).startDrag,
    _endDrag = __webpack_require__(2).endDrag,
    dndPageScroll = __webpack_require__(121),
    sendMessage = __webpack_require__(2).sendMessage,
    dndScope = __webpack_require__(79).moduleListDnDConstant,
    initialStateData = __webpack_require__(379),
    encodePath = __webpack_require__(43).encodePath,
    routeResolve = __webpack_require__(33),
    deleteModule = __webpack_require__(2).deleteModule,
    store = __webpack_require__(11);
var dragSpec = {
  beginDrag: function beginDrag(props, monitor, component) {
    store.dispatch(startDrag('moduleListCard'));
    dndPageScroll.showDragScroll(findDOMNode(component).className);
    return {
      name: props.name,
      type: 'moduleListCard'
    };
  },
  endDrag: function endDrag(props, monitor) {

propTypes: {
    name: React.PropTypes.string.isRequired,
    atts: listChecker,
    iconClass: React.PropTypes.string,
    title: React.PropTypes.string.isRequired
  },

iconAdder: function iconAdder() {

var curIcon = this.props.icon;
    return React.createElement(
      'svg',
      { className: 'tatsu-svg-icon' },
      React.createElement('use', { xlinkHref: curIcon })
    );
  },

addModule: function addModule() {

var dropLocation = this.props.drawerMeta.get('path'),
        addType = this.props.drawerMeta.get('addType'),
        atts = this.props.atts,
        moduleName = this.props.name;
    this.mouseLeaveHandler();
    store.dispatch(
    // addModule( dropLocation, moduleName, 1 == dropLocation.size%2 ? 'push' : 'insert' )
    _addModule(dropLocation, moduleName, addType));
  },

mouseEnterHandler: function mouseEnterHandler(title, event) {

store.dispatch(sendMessage(title, 'description'));
  },

mouseLeaveHandler: function mouseLeaveHandler(event) {

store.dispatch({ type: 'CLOSE_SNACKBAR' });
  },

render: function render() {
    var title = this.props.title,
        name = this.props.name,
        iconClassName = this.props.iconClass,
        moduleClassName = "be-pb-" + title + "-card",
        isDragging = this.props.isDragging || null,
        connectDragSource = this.props.connectDragSource || null,
        style = { backgroundColor: isDragging ? '#89C4F4' : '', opacity: isDragging ? '0.35' : '1' },
        draggable = this.props.draggable,
        result;

if ('string' == typeof name && 'gallery' === name) {
      return null;
    }
    if (draggable) {
      result = connectDragSource(React.createElement(
        'div',
        { className: 'be-pb-modulelist-card', style: style, onMouseEnter: this.mouseEnterHandler.bind(null, title), onMouseLeave: this.mouseLeaveHandler },
        React.createElement(
          'div',
          { className: moduleClassName },
          React.createElement(
            'span',
            { className: 'be-pb-modulelist-card-icon' },
            this.iconAdder()
          ),
          React.createElement(
            'div',
            { className: 'be-pb-modulelist-card-title' },
            React.createElement(
              'div',
              null,
              ' ',
              title
            )
          )
        )
      ));
    } else {
      result = React.createElement(
        'div',
        { onMouseEnter: this.mouseEnterHandler.bind(null, title), onMouseLeave: this.mouseLeaveHandler, onClick: this.addModule, className: 'be-pb-modulelist-card', style: style },
        React.createElement(
          'div',
          { className: moduleClassName },
          React.createElement(
            'span',
            { className: 'be-pb-modulelist-card-icon' },
            this.iconAdder()
          ),
          React.createElement(
            'div',
            { className: 'be-pb-modulelist-card-title' },
            React.createElement(
              'div',
              null,
              ' ',
              title
            )
          )
        )
      );
    }
    return result;
  }
});
module.exports = flow(DragSource(dndScope.module, dragSpec, collect))(DraggableModuleListCard);

/***/ }),
/* 680 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var React = __webpack_require__(0),
    HelpText = __webpack_require__(677),
    DraggableModuleListCard = __webpack_require__(679),
    parentComponentFinder = __webpack_require__(98);

var ModuleList = React.createClass({
  displayName: 'ModuleList',

propTypes: {},
  getInitialState: function getInitialState() {
    var tatsuEditorState = localStorage.getItem('tatsuEditorState');
    return {
      isHidden: tatsuEditorState ? JSON.parse(tatsuEditorState) : {}
    };
  },
  handleToggleCategory: function handleToggleCategory(i) {
    var newState = this.state.isHidden || {};
    newState[i] = !this.state.isHidden[i];
    this.setState({ isHidden: newState });
    localStorage.setItem('tatsuEditorState', JSON.stringify(newState));
  },
  render: function render() {
    var moduleCollection = this.props.moduleOptions.toOrderedMap(),
        filterText = this.props.filterText,
        changeHandler = this.props.changeHandler,
        path = !this.props.draggable ? this.props.drawerMeta.get('path') : '',
        parentComponent = path != '' ? parentComponentFinder(path) : '',
        showModule = true,
        defaultCategory = tatsuConfig.default_category,
        moduleCategories = tatsuConfig.categories;

var finalModuleCollection = Object.values(result);

return React.createElement(
      'div',
      { className: 'be-pb-module-container' },
      React.createElement(HelpText, { moduleName: this.props.draggable ? 'moduleListDraggable' : 'moduleListClickable' }),
      React.createElement(
        'div',
        { className: 'be-pb-module-search-wrapper' },
        React.createElement(
          'div',
          { className: 'be-pb-module-search' },
          React.createElement('input', { autoFocus: true, placeholder: 'Search modules', value: filterText, onInput: changeHandler, type: 'text', className: 'be-pb-module-search-input' }),
          React.createElement(
            'div',
            { className: 'be-pb-module-search-icon' },
            React.createElement(
              'svg',
              { width: '12px', height: '12px', viewBox: '0 0 12 12', version: '1.1', xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink' },
              React.createElement(
                'g',
                { id: 'Desktop-HD', stroke: 'none', strokeWidth: '1', fillRule: 'evenodd', transform: 'translate(-264.000000, -52.000000)' },
                React.createElement(
                  'g',
                  { id: 'Search', transform: 'translate(-1.000000, 40.000000)', fillRule: 'nonzero' },
                  React.createElement(
                    'g',
                    { id: 'noun_905006', transform: 'translate(265.000000, 12.000000)' },
                    React.createElement('path', { d: 'M8.44171779,7.84976526 C9.24662577,7.00469484 9.73742331,5.91549296 9.73742331,4.69483568 C9.73742331,2.10328638 7.55828221,0 4.86871166,0 C2.1791411,0 0,2.10328638 0,4.657277 C0,7.21126761 2.19877301,9.31455399 4.86871166,9.31455399 C5.88957055,9.31455399 6.85153374,8.99530516 7.59754601,8.50704225 L11.0920245,11.8497653 C11.209816,11.9624413 11.3276074,12 11.4650307,12 C11.602454,12 11.7398773,11.943662 11.8380368,11.8497653 C12.0539877,11.6431925 12.0539877,11.3239437 11.8380368,11.1173709 L8.44171779,7.84976526 Z M4.88834356,8.28169014 C2.80736196,8.28169014 1.0993865,6.64788732 1.0993865,4.657277 C1.0993865,2.66666667 2.80736196,1.03286385 4.88834356,1.03286385 C6.96932515,1.03286385 8.67730061,2.66666667 8.67730061,4.657277 C8.67730061,6.64788732 6.98895706,8.28169014 4.88834356,8.28169014 Z', id: 'Shape' })
                  )
                )
              )
            )
          )
        )
      ),
      React.createElement(
        'div',
        { className: 'be-pb-module-section-container' },
        finalModuleCollection.map(function (modules, key) {
          var _this = this;

return React.createElement(
            'div',
            { className: 'be-pb-module-list-section ' + (this.state.isHidden[modules.key] == true ? 'list-hidden' : 'list-visible'), key: key },
            React.createElement(
              'div',
              { className: 'be-pb-module-categories', onClick: function onClick(e) {
                  return _this.handleToggleCategory(modules.key);
                } },
              React.createElement(
                'span',
                { className: 'be-pb-module-label' },
                modules.title
              ),
              React.createElement(
                'span',
                { className: 'be-pb-module-icon tatsu-panel-icon' },
                React.createElement('span', { className: 'tatsu-panel-icon-vert' }),
                React.createElement('span', { className: 'tatsu-panel-icon-hor' })
              )
            ),
            React.createElement(
              'div',
              { className: 'be-pb-module-list-area ' + (filterText == '' ? 'hidden' : 'visible') },
              modules.items.map(function (el, index) {
                // Do not show Hamburger Component within Sliding Panel Column in Header Builder
                if (el.name === 'tatsu_hamburger_menu') {
                  if (this.props.draggable) {
                    // Do not show in Module List to limit user from adding Hamburger in Sidebar
                    showModule = false;
                  } else if (parentComponent != '' && parentComponent.get('name') === el.name && this.props.drawerMeta.get('path').size >= 4) {
                    showModule = false;
                  }
                }
                if (showModule) {
                  if ('core' != el.module.get('type') && 'sub_module' != el.module.get('type') && (this.props.draggable || 5 > this.props.drawerMeta.get('path').size || 'tatsu_inner_row' != el.name)) {
                    return React.createElement(DraggableModuleListCard, { key: index, drawerMeta: this.props.drawerMeta || null, draggable: this.props.draggable, isBuiltIn: el.module.get('is_built_in'), type: el.module.get('type'), name: el.name, atts: el.module.get('atts'), title: el.module.get('title'), icon: el.module.get('icon') });
                  }
                }
                showModule = true;
              }.bind(this))
            )
          );
        }.bind(this))
      )
    );
  }
});
module.exports = ModuleList;

/***/ }),
/* 681 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, $) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _select = __webpack_require__(65);

var _select2 = _interopRequireDefault(_select);

__webpack_require__(66);

var _actionCreator = __webpack_require__(2);

var _reducer = __webpack_require__(11);

var _reducer2 = _interopRequireDefault(_reducer);

var _reactMasonryComponent = __webpack_require__(1243);

var _reactMasonryComponent2 = _interopRequireDefault(_reactMasonryComponent);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Option = _select2.default.Option;

var infiniteLoaded = {
    sections: false,
    templates: false
};

var PrebuiltCollection = function (_React$Component) {
    _inherits(PrebuiltCollection, _React$Component);

function PrebuiltCollection(props) {
        _classCallCheck(this, PrebuiltCollection);

var _this = _possibleConstructorReturn(this, (PrebuiltCollection.__proto__ || Object.getPrototypeOf(PrebuiltCollection)).call(this, props));

_this.category = [];
        _this.infiniteScroll = false;
        _this.observer = null;
        _this.state = {
            category: Immutable.List()
        };
        _this.setCategory = _this.setCategory.bind(_this);
        _this.getFiltredCollectionBasedOnCategory = _this.getFiltredCollectionBasedOnCategory.bind(_this);
        _this.fetchTemplates = _this.fetchTemplates.bind(_this);
        return _this;
    }

_createClass(PrebuiltCollection, [{
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            var _this2 = this;

if (this.props.collection.size != nextProps.collection.size) {
                nextProps.collection.forEach(function (curCollection) {
                    if (curCollection.get('category')) {
                        curCollection.get('category').forEach(function (curCategory) {
                            if (-1 == _this2.category.indexOf(curCategory)) {
                                _this2.category.push(curCategory);
                            }
                        });
                    }
                });
            }
        }
    }, {
        key: 'fetchTemplates',
        value: function fetchTemplates() {
            var _this3 = this;

if (!this.infiniteScroll) {
                this.infiniteScroll = true;
                this.props.toggleLoading();
                $.ajax({
                    type: 'POST',
                    dataType: 'json',
                    url: tatsuConfig.ajaxurl,
                    data: {
                        action: 'tatsu_get_prebuilt_templates',
                        type: this.props.collectionType,
                        offset: this.props.collection.size,
                        nonce: tatsuConfig.nonce
                    },
                    beforeSend: function beforeSend(xhr) {
                        xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
                    }
                }).then(function (collection) {
                    if (1 === collection) {
                        infiniteLoaded[_this3.props.collectionType] = true;
                        _this3.observer = _this3.observer.disconnect();
                        _this3.forceUpdate();
                    } else {
                        collection = Immutable.fromJS(collection);
                        _reducer2.default.dispatch((0, _actionCreator.appendPrebuiltTemplates)(collection, _this3.props.collectionType));
                    }
                    _this3.infiniteScroll = false;
                    _this3.props.toggleLoading();
                });
            }
        }
    }, {
        key: 'componentDidUpdate',
        value: function componentDidUpdate(prevProps) {
            var _this4 = this;

if (0 == prevProps.collection.size && 0 !== this.props.collection.size && this.element) {
                this.observer = new IntersectionObserver(function (entries) {
                    entries.forEach(function (entry) {
                        var isIntersecting = entry.isIntersecting;

if (isIntersecting) {
                            _this4.fetchTemplates();
                        }
                    });
                }, {
                    root: document.querySelector(".ant-modal-body")
                });
                this.observer.observe(this.element);
            }
        }
    }, {
        key: 'componentDidMount',
        value: function componentDidMount() {
            var _this5 = this;

if (0 !== this.props.collection.size && this.element) {
                this.observer = new IntersectionObserver(function (entries) {
                    entries.forEach(function (entry) {
                        var isIntersecting = entry.isIntersecting;

if (isIntersecting) {
                            _this5.fetchTemplates();
                        }
                    });
                }, {
                    root: document.querySelector(".ant-modal-body")
                });
                this.observer.observe(this.element);
            }
            if (0 === this.category.length && 0 != this.props.collection.size) {
                this.props.collection.forEach(function (curCollection) {
                    if (curCollection.get('category')) {
                        curCollection.get('category').forEach(function (curCategory) {
                            if (-1 == _this5.category.indexOf(curCategory)) {
                                _this5.category.push(curCategory);
                            }
                        });
                    }
                });
                if (0 !== this.category.length) {
                    this.forceUpdate();
                }
            }
        }
    }, {
        key: 'setCategory',
        value: function setCategory(value) {
            this.setState({
                category: Immutable.List(value)
            });
        }
    }, {
        key: 'getFiltredCollectionBasedOnCategory',
        value: function getFiltredCollectionBasedOnCategory(collection) {
            var _this6 = this;

return 0 < this.state.category.size ? collection.filter(function (curCollection) {
                return _this6.state.category.some(function (curCategory) {
                    return curCollection.get('category').contains(curCategory);
                });
            }) : collection;
        }
    }, {
        key: 'render',
        value: function render() {
            var _this7 = this;

return PrebuiltCollection;
}(React.Component);

exports.default = PrebuiltCollection;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 682 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = {
	'1/1': 'one-col',
	'1/2': 'one-half',
	'1/3': 'one-third',
	'1/4': 'one-fourth',
	'1/5': 'one-fifth',
	'2/3': 'two-third',
	'3/4': 'three-fourth'
};

/***/ }),
/* 683 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports.layoutArray = ["1/1", "1/2+1/2", "1/3+2/3", "2/3+1/3", "1/3+1/3+1/3", "1/4+3/4", "3/4+1/4", "1/4+1/4+1/4+1/4", "1/4+1/2+1/4", "1/4+1/4+1/2", "1/2+1/4+1/4", "1/5+1/5+1/5+1/5+1/5"];

/***/ }),
/* 684 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports.integerRegex = /^-?\d*$/;
module.exports.hexRegex = /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i;
module.exports.rgbRegex = /rgb$(\d{1,3}), (\d{1,3}), (\d{1,3})$/;
module.exports.generalColorRegex = /(#(?:[0-9a-f]{2}){2,4}|#[0-9a-f]{3}|(?:rgba?|hsla?)$(?:\d+%?(?:deg|rad|grad|turn)?(?:,|\s)+){2,3}[\s\/]*[\d\.]+%?$)/i;

/***/ }),
/* 685 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var saveData = __webpack_require__(2).saveData,
    undo = __webpack_require__(2).undo,
    redo = __webpack_require__(2).redo,
    closeDrawer = __webpack_require__(2).closeDrawer,
    sendMessage = __webpack_require__(2).sendMessage,
    getKeyPath = __webpack_require__(39),
    copyAttributes = __webpack_require__(2).copyAttributes,
    pasteAttributes = __webpack_require__(2).pasteAttributes,
    store = __webpack_require__(11),
    getPathFromSelectionState = __webpack_require__(97),
    setDropEffect = __webpack_require__(2).setDropEffect,
    duplicateModule = __webpack_require__(2).duplicate,
    deleteModule = __webpack_require__(2).deleteModule,
    pushContentAndResetToolbar = __webpack_require__(2).pushContentAndResetToolbar;
module.exports = function (iframeDocument) {

[document, iframeDocument].forEach(function (currentDocument) {

currentDocument.addEventListener('keyup', function (event) {

if (18 == event.keyCode) {
                store.dispatch(setDropEffect('move'));
            }
        });

currentDocument.addEventListener('keydown', function (event) {

store.dispatch(setDropEffect('copy'));
            } else if (event[currentPlatform] && event.shiftKey && 'C' == String.fromCharCode(event.which)) {
                //fire copy atts
                store.dispatch(copyAttributes());
                event.preventDefault();
            } else if (event[currentPlatform] && event.shiftKey && 'V' == String.fromCharCode(event.which)) {
                //fire paste atts
                store.dispatch(pasteAttributes());
                event.preventDefault();
            } else {
                return true;
            }
        });
    });
};

/***/ }),
/* 686 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var moduleObj = __webpack_require__(159);

module.exports = function (moduleName, moduleOptions) {
    var newModuleDefn = new moduleObj(),
        newModule = newModuleDefn.getModuleMap(moduleName, moduleOptions);

return newModule;
};

/***/ }),
/* 687 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var moduleObj = __webpack_require__(159),
    addRow = __webpack_require__(363);

module.exports.addSection = function addSection(moduleOptions) {

var newSectionDefn = new moduleObj(),
	    newSection = newSectionDefn.getModuleMap('tatsu_section', moduleOptions),
	    newInnerRow = addRow(moduleOptions);
	newSection = newSection.setIn(['inner', 0], newInnerRow);
	return newSection;
};

/***/ }),
/* 688 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports.CssAnimateCons = function CssAnimateCons(moduleName, id, animationToggle, animationType, animationDelay) {

this.currentAnimationType = '';
	this.currentAnimationToggle = '';
	this.currentAnimationDelay = '0';
};

module.exports.CssAnimateCons.prototype.init = function (atoggle, atype, aDelay) {

this.currentAnimationType = atype;
	this.currentAnimationToggle = atoggle;
	this.currentAnimationDelay = aDelay || '0';
}, module.exports.CssAnimateCons.prototype.triggerAnimation = function (moduleName, id, animationToggle, animationType, animationDelay) {
	var data = {
		type: 'csstrigger',
		moduleName: moduleName,
		shouldUpdate: true,
		id: id
	},
	    jsonData;
	if (this.currentAnimationType != animationType || '0' === this.currentAnimationToggle && '1' === animationToggle || 'undefined' != typeof animationDelay && '' != animationDelay && this.animationDelay != animationDelay) {
		jsonData = JSON.stringify(data);
		document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
		this.currentAnimationType = animationType;
		this.currentAnimationToggle = animationToggle;
		this.animationDelay = animationDelay;
	} else {
		return;
	}
};

/***/ }),
/* 689 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function componentFinder(currentState, path) {

var index,
	    level = path.size;
	for (index = 0; index < level; index++) {
		if ('undefined' != typeof currentState) {
			currentState = currentState.getIn(['inner', path.get(index)]);
		} else {
			break;
		}
	}
	return currentState;
};

/***/ }),
/* 690 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var getKeyPath = __webpack_require__(39),
    deleteModule = __webpack_require__(2).deleteModule,
    triggerPaste = __webpack_require__(2).triggerPaste,
    sendMessage = __webpack_require__(2).sendMessage,
    stripOutputBeforeSave = __webpack_require__(377),
    store = __webpack_require__(11),
    getShortcode = __webpack_require__(370);
module.exports = function (targetDocument, stateData) {

['cut', 'copy'].forEach(function (currentEvent) {

targetDocument.addEventListener(currentEvent, function (event) {

return curSelection.get('path');
                });
                moduleTitle = 'Multiple Modules';
                modulePath.forEach(function (curPath) {

pathArray = getKeyPath(curPath, '', '');
                    moduleData = currentPageContent.getIn(pathArray);
                    if ('tatsu_column' == moduleData.get('name') || 'tatsu_inner_column' == moduleData.get('name')) {
                        colCountInMulti++;
                        return;
                    }
                    shortcode = shortcode + getShortcode(stripOutputBeforeSave(moduleData, moduleOptions));
                });
                if (colCountInMulti == modulePath.size) {
                    store.dispatch(sendMessage('Columns/Inner Columns cannot be cut/copied', 'error'));
                } else {
                    event.clipboardData.setData('text/plain', shortcode);
                    if ('cut' == currentEvent) {
                        store.dispatch(deleteModule(modulePath));
                        store.dispatch(sendMessage(moduleTitle + ' moved to Clipboard', 'success'));
                    } else {
                        store.dispatch(sendMessage(moduleTitle + ' copied to Clipboard', 'success'));
                    }
                }
                return;
            } else {
                store.dispatch(sendMessage('Click on a module to ' + currentEvent + ' it', 'error'));
                return;
            }
        });
    });
    targetDocument.addEventListener('paste', function (event) {

if (-1 < targetDocument.activeElement.className.indexOf('tatsu-inline-editor') || 'tatsu-inline-color-input' == targetDocument.activeElement.id || 'tatsu-inline-link-area' == targetDocument.activeElement.id) {
            return;
        }
        event.preventDefault();
        var shortcodeString = event.clipboardData.getData('text/plain'),
            getInArray = [],
            modulePathString,
            modulePath,
            currentLocation = window.location.pathname,
            currentLocationArray = currentLocation.split("/"),
            pathIndex = -1 < currentLocation.indexOf('moduleEditor') ? currentLocationArray.length - 2 : -1 < currentLocation.indexOf('layoutManager') ? currentLocationArray.length - 1 : -1,
            currentState = store.getState().tatsu_page_content.get('present');
        if (-1 != pathIndex && '' != currentLocationArray[pathIndex]) {
            modulePathString = decodeURIComponent(currentLocationArray[pathIndex]);
            modulePath = Immutable.List(JSON.parse("[" + modulePathString + "]"));
            store.dispatch(triggerPaste(modulePath, shortcodeString));
            return;
        } else {
            store.dispatch(sendMessage('Click on a module to paste contents', 'error'));
            return;
        }
    });
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 691 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _EllipsisOutline = __webpack_require__(574);

Object.defineProperty(exports, 'EllipsisOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_EllipsisOutline).default;
  }
});

var _CloseOutline = __webpack_require__(571);

Object.defineProperty(exports, 'CloseOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CloseOutline).default;
  }
});

var _CheckOutline = __webpack_require__(569);

Object.defineProperty(exports, 'CheckOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CheckOutline).default;
  }
});

var _LoadingOutline = __webpack_require__(583);

Object.defineProperty(exports, 'LoadingOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_LoadingOutline).default;
  }
});

var _CheckCircleOutline = __webpack_require__(568);

Object.defineProperty(exports, 'CheckCircleOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CheckCircleOutline).default;
  }
});

var _InfoCircleOutline = __webpack_require__(581);

Object.defineProperty(exports, 'InfoCircleOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_InfoCircleOutline).default;
  }
});

var _CloseCircleOutline = __webpack_require__(570);

Object.defineProperty(exports, 'CloseCircleOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CloseCircleOutline).default;
  }
});

var _ExclamationCircleOutline = __webpack_require__(575);

Object.defineProperty(exports, 'ExclamationCircleOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_ExclamationCircleOutline).default;
  }
});

var _CheckCircleFill = __webpack_require__(559);

Object.defineProperty(exports, 'CheckCircleFill', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CheckCircleFill).default;
  }
});

var _InfoCircleFill = __webpack_require__(562);

Object.defineProperty(exports, 'InfoCircleFill', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_InfoCircleFill).default;
  }
});

var _CloseCircleFill = __webpack_require__(560);

Object.defineProperty(exports, 'CloseCircleFill', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CloseCircleFill).default;
  }
});

var _ExclamationCircleFill = __webpack_require__(561);

Object.defineProperty(exports, 'ExclamationCircleFill', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_ExclamationCircleFill).default;
  }
});

var _UpOutline = __webpack_require__(590);

Object.defineProperty(exports, 'UpOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_UpOutline).default;
  }
});

var _DownOutline = __webpack_require__(573);

Object.defineProperty(exports, 'DownOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_DownOutline).default;
  }
});

var _LeftOutline = __webpack_require__(582);

Object.defineProperty(exports, 'LeftOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_LeftOutline).default;
  }
});

var _RightOutline = __webpack_require__(588);

Object.defineProperty(exports, 'RightOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_RightOutline).default;
  }
});

var _RedoOutline = __webpack_require__(587);

Object.defineProperty(exports, 'RedoOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_RedoOutline).default;
  }
});

var _CalendarOutline = __webpack_require__(565);

Object.defineProperty(exports, 'CalendarOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CalendarOutline).default;
  }
});

var _SearchOutline = __webpack_require__(589);

Object.defineProperty(exports, 'SearchOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_SearchOutline).default;
  }
});

var _BarsOutline = __webpack_require__(564);

Object.defineProperty(exports, 'BarsOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_BarsOutline).default;
  }
});

var _StarFill = __webpack_require__(563);

Object.defineProperty(exports, 'StarFill', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_StarFill).default;
  }
});

var _FilterOutline = __webpack_require__(578);

Object.defineProperty(exports, 'FilterOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_FilterOutline).default;
  }
});

var _CaretUpOutline = __webpack_require__(567);

Object.defineProperty(exports, 'CaretUpOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CaretUpOutline).default;
  }
});

var _CaretDownOutline = __webpack_require__(566);

Object.defineProperty(exports, 'CaretDownOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_CaretDownOutline).default;
  }
});

var _PlusOutline = __webpack_require__(586);

Object.defineProperty(exports, 'PlusOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_PlusOutline).default;
  }
});

var _FileOutline = __webpack_require__(577);

Object.defineProperty(exports, 'FileOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_FileOutline).default;
  }
});

var _FolderOpenOutline = __webpack_require__(579);

Object.defineProperty(exports, 'FolderOpenOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_FolderOpenOutline).default;
  }
});

var _FolderOutline = __webpack_require__(580);

Object.defineProperty(exports, 'FolderOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_FolderOutline).default;
  }
});

var _PaperClipOutline = __webpack_require__(584);

Object.defineProperty(exports, 'PaperClipOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_PaperClipOutline).default;
  }
});

var _PictureOutline = __webpack_require__(585);

Object.defineProperty(exports, 'PictureOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_PictureOutline).default;
  }
});

var _EyeOutline = __webpack_require__(576);

Object.defineProperty(exports, 'EyeOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_EyeOutline).default;
  }
});

var _DeleteOutline = __webpack_require__(572);

Object.defineProperty(exports, 'DeleteOutline', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_DeleteOutline).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ }),
/* 692 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

Object.defineProperty(exports, "__esModule", {
    value: true
});
var beFieldBackwardComp = function beFieldBackwardComp(attMap) {
    var attType = attMap.get('type'),
        attName = attMap.get('att_name'),
        options = attMap.get('options');

if ('input_group' === attType) {
        var unitArray = [],
            labels = [],
            min = 0;

if (Immutable.Map.isMap(options) ? !options.has('unit') : true) {
            if ('border' === attName) {
                unitArray = ['px'];
            } else {
                unitArray = ['px', '%'];
            }
        } else {
            unitArray = options.get('unit');
        }

if (Immutable.Map.isMap(options) ? !options.has('labels') : true) {
            labels = ['top', 'right', 'bottom', 'left'];
        } else {
            labels = options.get('labels');
        }

if (!Immutable.Map.isMap(options) || !options.has('min')) {
            if ('padding' === attName || 'border' === attName) {
                min = 0;
            } else {
                min = -Infinity;
            }
        } else {
            min = options.get('min');
        }

/***/ }),
/* 693 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports.arrayFilterer = function arrayFilterer(element, filterer) {
  if (element.indexOf(filterer) > -1) {
    return true;
  }
};

module.exports.convertToGrid = function convertToGrid(arrayData) {
  var row = Immutable.List(),
      fontList = Immutable.List(),
      arrayList = Immutable.List(arrayData),
      arrayList = arrayList.insert(0, 'clear');
  arrayList.forEach(function (item, index) {
    if (index != 0 && index % 4 === 0) {
      fontList = fontList.push(row);
      row = Immutable.List();
      row = row.push(item);
    } else {
      row = row.push(item);
    }
  });
  fontList = fontList.push(row);
  return fontList;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 694 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
var screenVisibilityOption = exports.screenVisibilityOption = {
    multi: true,
    options: {
        desktop: {
            svg: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-desktop',
            label: 'Desktop'
        },
        laptop: {
            svg: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-laptop',
            label: 'Laptop'
        },
        tablet: {
            svg: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-tablet',
            label: 'Tablet'
        },
        mobile: {
            svg: tatsuConfig.plugin_url + '/builder/svg/tatsu.svg#icon-mobile',
            label: 'Mobile'
        }
    }
};

var boxShadowPresets = exports.boxShadowPresets = {
    Light: '0px 0px 15px 0px rgba(198,202,202,0.4)',
    Medium: '0px 5px 30px 0px rgba(214,215,216,0.57)',
    Dark: '0px 5px 45px 0px rgba(175,177,177,0.57)',
    None: '0px 0px 0px 0px rgba(0,0,0,0)'
};

var getDrawerTransitionObj = exports.getDrawerTransitionObj = function getDrawerTransitionObj(width, duration, placement, cubicBezier) {
    return {
        overlay: {
            defaultStyle: {
                transition: 'opacity ' + duration + 'ms ' + cubicBezier,
                opacity: 0
            },
            entering: {
                opacity: 1
            },
            entered: {
                opacity: 1
            }
        },
        drawer: {
            defaultStyle: {
                transition: 'transform ' + duration + 'ms ' + cubicBezier,
                transform: 'translate3d(' + ('left' == placement ? '-' + width : width) + ',0,0)'
            },
            entering: {
                transform: 'translate3d(0,0,0)'
            },
            entered: {
                transform: 'translate3d(0,0,0)'
            }
        }
    };
};

var getPopoverTransitionObj = exports.getPopoverTransitionObj = function getPopoverTransitionObj(duration, cubicBezier, placement) {
    return {
        defaultStyle: {
            transition: 'transform ' + duration + 'ms ' + cubicBezier + ', opacity ' + duration + 'ms ' + cubicBezier,
            transform: 'scale(0, 0)',
            opacity: '0',
            transformOrigin: placement.vertical + ' ' + placement.horizontal
        },
        entering: {
            transform: 'scale(1, 1)',
            opacity: '1'
        },
        entered: {
            transform: 'scale(1, 1)',
            opacity: '1'
        }
    };
};

var validWidthUnits = exports.validWidthUnits = ['%', 'px', 'em', 'rem'];
var validDrawerPlacements = exports.validDrawerPlacements = ['left', 'right'];

var birdsEyeViewMenu = exports.birdsEyeViewMenu = {
    base: ['Edit', 'Duplicate', 'Delete'],
    section: ['Rename', 'Save As Template', 'Add Section Above', 'Add Section Below']
};

/***/ }),
/* 695 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
var inlineElements = ['switch', 'color', 'icon_picker', 'gradient_color', 'select', 'text', 'svg_icon_picker'];
exports.default = inlineElements;

/***/ }),
/* 696 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _EditorHelpers = __webpack_require__(26);

/***/ }),
/* 697 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

exports.default = function (value) {
    value = 'string' == typeof value ? value.toLowerCase().trim() : value;
    switch (value) {
        case 'false':
        case '0':
        case 'no':
            return false;
        default:
            return Boolean(value);
    }
};

/***/ }),
/* 698 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
var debounce = function () {
    var timer = 0;
    return function (callback, ms, args) {
        clearTimeout(timer);
        timer = setTimeout(function () {
            timer = 0;
            callback(args);
        }, ms);
    };
}();
exports.default = debounce;

/***/ }),
/* 699 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

exports.default = function () {
    for (var _len = arguments.length, classNamesObj = Array(_len), _key = 0; _key < _len; _key++) {
        classNamesObj[_key] = arguments[_key];
    }

return classNamesObj.reduce(function (arg1, arg2, index) {
        return 'object' == (typeof arg2 === 'undefined' ? 'undefined' : _typeof(arg2)) && null != arg2 ? Object.keys(arg2).reduce(function (classNames, key) {
            return arg2[key] ? classNames + ' ' + key : classNames;
        }, arg1) : 0 == index && 'string' == typeof arg2 ? arg2 : 'string' != typeof arg2 ? arg1 : arg1 + ' ' + arg2;
    }, '');
};

/***/ }),
/* 700 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var getValueAndUnit = function getValueAndUnit(value) {
  if (!isNaN(value)) {
    value = String(value);
  }
  return {
    value: 'string' == typeof value ? parseFloat(value) : null,
    unit: 'string' == typeof value ? value.match(/[\d.\-\+]*\s*(.*)/)[1] || '' : ''
  };
};
exports.default = getValueAndUnit;

/***/ }),
/* 701 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _EditorHelpers = __webpack_require__(26);

/***/ }),
/* 702 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _EditorHelpers = __webpack_require__(26);

exports.default = function (obj) {
    var objType = (0, _EditorHelpers.getObjectType)(obj);
    if ((0, _EditorHelpers.isImmutable)(obj)) {
        return 0 == obj.size;
    } else if ('[object Array]' == objType) {
        return 0 == obj.length;
    } else if ('[object Object]' == objType) {
        return 0 == Object.keys(obj).length && Object === obj.constructor;
    } else {
        return !obj;
    }
};

/***/ }),
/* 703 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

Object.defineProperty(exports, "__esModule", {
    value: true
});
var isImmutable = function isImmutable(obj) {
    /*
    * isImmutable is not exposed under v4.* - https://github.com/facebook/immutable-js/issues/1165
    */
    return 'undefined' != typeof Immutable && Immutable.Iterable.isIterable(obj);
};
exports.default = isImmutable;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 704 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
var isShallowEqual = function isShallowEqual(obj1, obj2) {
    for (var key in obj1) {
        if (!(key in obj2) || obj1[key] !== obj2[key]) {
            return false;
        }
    }
    for (var key in obj2) {
        if (!(key in obj1) || obj2[key] !== obj1[key]) return false;
    }
    return true;
};
exports.default = isShallowEqual;

/***/ }),
/* 705 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _EditorHelpers = __webpack_require__(26);

var isValidDataStructure = function isValidDataStructure(obj) {
    return (0, _EditorHelpers.isImmutable)(obj) || '[object Object]' == (0, _EditorHelpers.getObjectType)(obj);
};
exports.default = isValidDataStructure;

/***/ }),
/* 706 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _EditorHelpers = __webpack_require__(26);

/***/ }),
/* 707 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function($) {

module.exports = function fireAjax(dataObject) {

dataObject.nonce = tatsuConfig.nonce;
    return $.ajax({
        type: 'POST',
        url: tatsuConfig.ajaxurl,
        data: dataObject,
        beforeSend: function beforeSend(xhr) {
            xhr.setRequestHeader('X-WP-Nonce', tatsuConfig.nonce);
        }
    });
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 708 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function (currentScrollPosition) {

var iframeDocument = document.getElementById('tatsu-preview').contentDocument,
        iframeHtmlTag = iframeDocument.getElementsByTagName('html')[0],
        copyPasteHelper = iframeDocument.getElementById('tatsu-copy-paste-helper');
    if (copyPasteHelper) {
        copyPasteHelper.value = ' ';
        copyPasteHelper.focus();
        copyPasteHelper.select();
        if (currentScrollPosition) {
            iframeDocument.body.scrollTop = currentScrollPosition;
            iframeHtmlTag.scrollTop = currentScrollPosition;
        }
    }
};

/***/ }),
/* 709 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

var getAttsFromSelectionState = __webpack_require__(710);
module.exports = function (selectionState, tatsuPageContent, moduleOptions) {

var atts = Immutable.OrderedMap(),
        responsiveAttDefaultValue = Immutable.Map({
        d: '',
        l: null,
        t: null,
        m: null
    }),
        attsList = getAttsFromSelectionState(selectionState, tatsuPageContent),
        moduleName = selectionState.getIn(['selectionList', 0, 'name']);
    moduleOptions.getIn([moduleName, 'atts']).forEach(function (attMap) {

if (attMap.get('responsive')) {
            atts = atts.set(attMap.get('att_name'), responsiveAttDefaultValue);
        } else {
            atts = atts.set(attMap.get('att_name'), '');
        }
    });
    atts = atts.map(function (attValue, attKey) {

var shouldChangeValue = attsList.reduce(function (a, b) {

return true === a ? true : Immutable.Map.isMap(a.get(attKey)) ? Immutable.is(a.get(attKey), b.get(attKey)) ? a : true : a.get(attKey) == b.get(attKey) ? a : true;
        });
        if (Immutable.Map.isMap(shouldChangeValue)) {
            return attsList.getIn([0, attKey]);
        }
        return attValue;
    });
    return atts;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 710 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var keyPath = __webpack_require__(39);
module.exports = function (selectionState, pageContent) {

var pathArray;
    return selectionState.get('selectionList').map(function (curSelection) {

pathArray = keyPath(curSelection.get('path'), '', 'atts');
        return pageContent.getIn(pathArray);
    });
};

/***/ }),
/* 711 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function (attValue) {

if (!Immutable.Map.isMap(attValue)) {
        attValue = Immutable.Map(attValue);
    }
    if (attValue.has('id') && attValue.has('color')) {
        //Update color values from Color Hub Store
        if (window.colorhub) {
            var idAsArray = attValue.get('id').split(':'),
                type = idAsArray[0],
                key = idAsArray[1],
                colorHubData = window.colorhub,
                colorMappedToID;
            if (type == 'swatch' && null != colorHubData.swatches[key]) {
                colorMappedToID = colorHubData.swatches[key].color;
                attValue = attValue.set('color', colorMappedToID);
            } else if (type == 'palette') {
                var palettes = window.colorhub.palettes;
                colorMappedToID = palettes.allPalettes[palettes.currentPalette][key];
                attValue = attValue.set('color', colorMappedToID);
            }
            return attValue;
        } else {
            return attValue;
        }
    } else {
        return attValue;
    }
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 712 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function (layout, columnName) {

if (columnName === 'tatsu_header_column') {
    switch (layout) {
      case '1/1':
        return { d: 100, l: 100, t: 100, m: 100 };
      case '1/2':
        return { d: 50, l: 50, t: 50, m: 50 };
      case '1/3':
        return { d: 33.33, l: 33.33, t: 33.33, m: 33.33 };
      case '1/4':
        return { d: 25, l: 25, t: 25, m: 25 };
      case '1/5':
        return { d: 20, l: 20, t: 20, m: 20 };
      case '2/3':
        return { d: 66.67, l: 66.67, t: 66.67, m: 66.67 };
      case '3/4':
        return { d: 75, l: 75, t: 75, m: 75 };
      default:
        return { d: 100, l: 100, t: 100, m: 100 };
    }
  } else {
    switch (layout) {
      case '1/1':
        return { d: 100, l: 100, t: 100, m: 100 };
      case '1/2':
        return { d: 50, l: 50, t: 50, m: 100 };
      case '1/3':
        return { d: 33.33, l: 33.33, t: 33.33, m: 100 };
      case '1/4':
        return { d: 25, l: 25, t: 25, m: 100 };
      case '1/5':
        return { d: 20, l: 20, t: 20, m: 100 };
      case '2/3':
        return { d: 66.67, l: 66.67, t: 66.67, m: 100 };
      case '3/4':
        return { d: 75, l: 75, t: 75, m: 100 };
      default:
        return { d: 100, l: 100, t: 100, m: 100 };
    }
  }
};

/***/ }),
/* 713 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(jQuery) {

module.exports = function getHeaderFonts(module, moduleOptions, fontArray) {

if (!fontArray) {
        fontArray = {};
    }

var children = module.get('inner'),
        currentAtts = module.get('atts'),
        childrenCount = 'undefined' != typeof children ? children.size : 0,
        currentModule = module.get('name'),
        attsFromModuleOptions = moduleOptions.getIn([currentModule, 'atts']);

for (var index = 0; index < childrenCount; index++) {
        var childModule = children.get(index),
            childName = childModule.get('name'),
            atts = moduleOptions.getIn([childName, 'atts']);
        if (null != atts) {
            atts.find(function (item) {
                if (item.get('type') === 'typography') {
                    childModule.getIn(['atts', item.get('att_name')]).forEach(function (val, key) {
                        var tempFont = '',
                            tempVariant = '',
                            tempFontObj;
                        if (val) {
                            tempFont = val.get('font-family');
                            tempVariant = parseInt(val.get('font-variant'));
                        }
                        if (tempFont) {
                            tempFont = tempFont.split(':');

if (tempFont[0] === 'schemes') {
                                tempFont = window.typehub_font_options.schemes[tempFont[1]].fontFamily;
                                tempFont = tempFont.split(':');
                            }

if (_typeof(fontArray[tempFont[0]]) === 'object') {
                                if (fontArray[tempFont[0]][tempFont[1]]) {
                                    fontArray[tempFont[0]][tempFont[1]].push(tempVariant);
                                } else {
                                    tempFontObj = {};
                                    tempFontObj[tempFont[1]] = [tempVariant];
                                    fontArray[tempFont[0]] = jQuery.extend({}, fontArray[tempFont[0]], tempFontObj);
                                }
                            } else {
                                tempFontObj = {};
                                tempFontObj[tempFont[1]] = [tempVariant];
                                fontArray[tempFont[0]] = tempFontObj;
                            }
                        }
                    });
                }
            });
        }
        getHeaderFonts(childModule, moduleOptions, fontArray);
    }
    return fontArray;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))

/***/ }),
/* 714 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
                  value: true
});
exports.default = getPrettyDate;
function getPrettyDate() {
                  var monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
                  var dateObj = new Date();
                  var monthIndex = dateObj.getMonth();
                  var year = dateObj.getFullYear();
                  return monthNames[monthIndex] + " " + year;
}

/***/ }),
/* 715 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function (routePath, selectionState) {

var routePath = routePath || '',
        selectionList = Immutable.Map.isMap(selectionState) ? selectionState.get('selectionList') : Immutable.List();
    return 'multiSelect' == routePath ? 0 != selectionList.size ? selectionList.map(function (curSelection) {

return curSelection.get('path');
    }) : Immutable.List() : Immutable.List(JSON.parse("[" + routePath + "]"));
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 716 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var modifyAttsBeforeAddModule = __webpack_require__(372);

module.exports = function (selectedPath, selectedModule, clipboardModule, builderMode) {

var selectedModuleType = selectedModule.get('type'),
        clipboardModuleType = clipboardModule.get('type'),
        targetPath;

// if( 'tatsu_slide_menu_column' == selectedModule.get( 'name' ) ){
    //     clipboardModule = modifyAttsBeforeAddModule( clipboardModule , 'header_sidebar_module', 'new_module' );
    // }

switch (clipboardModuleType) {
        case 'core':
            if ('tatsu_section' == clipboardModule.get('name') || 'tatsu_header_row' == clipboardModule.get('name')) {
                targetPath = selectedPath.splice(1);
            } else if ('tatsu_row' == clipboardModule.get('name')) {
                if (2 <= selectedPath.size) {
                    targetPath = selectedPath.splice(2);
                } else {
                    var selectedModuleChildren = selectedModule.get('inner');
                    if (0 != selectedModuleChildren.size) {
                        targetPath = selectedPath.push(selectedModuleChildren.size - 1);
                    } else {
                        //failure case
                        targetPath = null;
                    }
                }
            } else if ('tatsu_column' == clipboardModule.get('name') || 'tatsu_inner_column' == clipboardModule.get('name') || 'tatsu_header_column' == clipboardModule.get('name') || 'tatsu_slide_menu_column' == clipboardModule.get('name')) {
                //failure case
                targetPath = null;
            }
            break;
        case 'single':
        case 'multi':
            if (3 <= selectedPath.size && builderMode === 'header_builder') {
                if (selectedModule.get('name') === 'tatsu_slide_menu_column') {
                    if ('tatsu_hamburger_menu' == clipboardModule.get('name')) {
                        targetPath = null;
                    } else {
                        if (0 == selectedModule.get('inner').size) {
                            targetPath = selectedPath.push(0);
                        } else {
                            targetPath = selectedPath.push(selectedModule.get('inner').size - 1);
                        }
                    }
                } else {
                    targetPath = selectedPath.splice(selectedPath.size);
                }
            } else if (4 <= selectedPath.size && builderMode === 'page_builder') {
                if (4 < selectedPath.size && 'tatsu_inner_row' == clipboardModule.get('name')) {
                    targetPath = null;
                } else if (1 == selectedPath.size % 2) {
                    if (0 == selectedModule.get('inner').size) {
                        targetPath = selectedPath.push(0);
                    } else {
                        targetPath = selectedPath.push(selectedModule.get('inner').size - 1);
                    }
                } else {
                    targetPath = selectedPath.splice(selectedPath.size);
                }
            } else {
                if ('tatsu_section' == selectedModule.get('name') || 'tatsu_header_row' == selectedModule.get('name')) {
                    if (0 != selectedModule.get('inner').size) {
                        var lastRowIndex = selectedModule.get('inner').size - 1,
                            lastRow = selectedModule.getIn(['inner', lastRowIndex]),
                            lastColumnIndex = lastRow.get('inner').size - 1;
                        lastColumn = lastRow.getIn(['inner', lastColumnIndex]), lastModuleIndex;
                        if (0 == lastColumn.get('inner').size) {
                            lastModuleIndex = 0;
                        } else {
                            lastModuleIndex = lastColumn.get('inner').size - 1;
                        }
                        targetPath = selectedPath.push(lastRowIndex, lastColumnIndex, lastModuleIndex);
                    } else {
                        //error case
                        targetPath = null;
                    }
                } else if ('tatsu_row' == selectedModule.get('name')) {
                    var lastColumnIndex = selectedModule.get('inner').size - 1,
                        lastColumn = selectedModule.getIn(['inner', lastColumnIndex]),
                        lastModuleIndex;
                    if (0 == lastColumn.get('inner').size) {
                        lastModuleIndex = 0;
                    } else {
                        lastModuleIndex = lastColumn.get('inner').size - 1;
                    }
                    targetPath = selectedPath.push(lastColumnIndex, lastModuleIndex);
                } else if ('tatsu_column' == selectedModule.get('name') || 'tatsu_header_column' == selectedModule.get('name') || 'tatsu_slide_menu_column' == selectedModule.get('name')) {

if (0 == selectedModule.get('inner').size) {
                        targetPath = selectedPath.push(0);
                    } else {
                        targetPath = selectedPath.push(selectedModule.get('inner').size - 1);
                    }
                } else {
                    //error case
                    targetPath = null;
                }
            }
            break;
        default:
            targetPath = null;
            break;
    }
    return targetPath;
};

/***/ }),
/* 717 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function loadFont(fontt) {
    var fonttSplit = fontt.split(':');

switch (fonttSplit[0]) {
        case 'google':
            if (window.WebFont) {
                window.WebFont.load({
                    google: {
                        families: [fonttSplit[1] + ':100,200,300,400,500,600,700,800,900']
                    },
                    context: frames["tatsu-preview"].contentWindow
                });
            } else {
                //message.error("Please Check Internet Connection");
            }
            break;
        case 'typekit':
            if (window.WebFont) {
                window.WebFont.load({
                    typekit: {
                        id: window.typehub_font_options ? window.typehub_font_options.typekit_id : ''
                    },
                    context: frames["tatsu-preview"].contentWindow
                });
            } else {
                //message.error("Please Check Internet Connection");
            }
            break;
        case 'custom':
            if (window.WebFont) {
                window.WebFont.load({
                    custom: {
                        families: [fonttSplit[1]],
                        urls: [window.typehub_font_options.custom[fonttSplit[1]].src]
                    },
                    context: frames["tatsu-preview"].contentWindow,
                    timeout: 2000
                });
            } else {
                // message.error("Please Check Internet Connection");
            }
            break;
        case 'schemes':
            if (window.typehub_font_options.schemes[fonttSplit[1]]) {
                loadFont(window.typehub_font_options.schemes[fonttSplit[1]].fontFamily);
            }
            break;
        default:
            break;

}
};

/***/ }),
/* 718 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function modifyAttFormat(currentAtts, attsFromModuleOptions) {

var index, currentModuleOption, currentAttValue;

if (null != currentAtts && null != attsFromModuleOptions) {

currentAtts = currentAtts.map(function (attValue, attName) {

if (Immutable.Map.isMap(attValue)) {

// var attsIndex = currentAtts.keySeq().indexOf( attName );

// currentModuleOption = attsFromModuleOptions.get(attsIndex);
                var currentModuleOption = attsFromModuleOptions.find(function (attMap) {
                    return attName == attMap.get('att_name');
                });
                if (Immutable.Map.isMap(currentModuleOption)) {
                    if (currentModuleOption.get('type') === 'color' && attValue != '' && Immutable.Map.isMap(attValue)) {
                        if (attValue.has('active')) {
                            var activeState = attValue.get('active'),
                                attValueColor = {},
                                attValueTemp;
                            if (Immutable.Map.isMap(attValue.getIn([activeState]))) {
                                attValueTemp = attValue.getIn([activeState, 'color']);
                            } else {
                                attValueTemp = attValue.getIn([activeState]).color;
                            }

if (attValue.has('id')) {
                                attValue = {
                                    id: attValue.get('id'),
                                    color: attValueTemp
                                };
                            } else {
                                attValue = attValueTemp;
                            }
                        }
                    }
                    if (currentModuleOption.has('responsive')) {
                        if (currentModuleOption.get('responsive') === true) {
                            if (Immutable.Map.isMap(attValue) && currentModuleOption.get('type') != 'color') {
                                attValue.entrySeq().forEach(function (displayValue) {
                                    attValue = displayValue[1] === null ? attValue.delete(displayValue[0]) : attValue;
                                });
                            }
                            return attValue;
                        }
                    }
                }
            }
            return attValue;
        });

return currentAtts;
    }
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 719 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var isEmpty = __webpack_require__(5);

var modifyAttsBeforeCSSCompute = {

tatsu_column: function tatsu_column(atts) {
        return atts.map(function (attValue, attKey) {
            if (attKey == 'z_index') {
                attValue = attValue != 0 ? parseInt(attValue) + 2 : '';
            }
            return attValue;
        });
    },

tatsu_section: function tatsu_section(atts) {
        return atts.map(function (attValue, attKey) {
            if (attKey == 'z_index') {
                attValue = attValue != 0 ? parseInt(attValue) + 2 : '';
            }
            return attValue;
        });
    },

tatsu_call_to_action: function tatsu_call_to_action(atts) {
        if (isEmpty(atts.get('border_color'))) {
            atts = atts.set('border_color', 'transparent');
        }
        if (isEmpty(atts.get('hover_border_color'))) {
            atts = atts.set('hover_border_color', atts.get('border_color'));
        }
        return atts;
    }
};

module.exports = modifyAttsBeforeCSSCompute;

/***/ }),
/* 720 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function normalizePathForMultipleDelete(pathList, builderMode) {

return pathList.map(function (curPath, index) {
        var slicedPath = pathList.slice(0, index),
            updatedCurPath = curPath;
        slicedPath.forEach(function (curSlicedPath, index) {
            if (null == curPath) {
                return;
            } else if (curSlicedPath.size <= curPath.size) {
                if (Immutable.is(curSlicedPath, curPath.slice(0, curSlicedPath.size))) {
                    updatedCurPath = null;
                } else if (Immutable.is(curSlicedPath.pop(), curPath.slice(0, curSlicedPath.size - 1)) && curSlicedPath.last() < curPath.slice(0, curSlicedPath.size).last()) {
                    if ('header_builder' === builderMode || 3 != curSlicedPath.size && 5 != curSlicedPath.size) {
                        updatedCurPath = updatedCurPath.set(curSlicedPath.size - 1, updatedCurPath.get(curSlicedPath.size - 1) - 1);
                    }
                }
            }
        });
        return updatedCurPath;
    });
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 721 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function normalizePathForMultipleDuplicate(pathList) {

return pathList.map(function (curPath, index) {

var splicedPath = pathList.slice(0, index),
            updatedCurPath = curPath;
        splicedPath.forEach(function (curSplicedPath) {

if (curSplicedPath.size <= curPath.size && 3 != curSplicedPath.size && 5 != curSplicedPath.size && Immutable.is(curSplicedPath.pop(), curPath.slice(0, curSplicedPath.size - 1)) && curSplicedPath.last() < curPath.get(curSplicedPath.size - 1)) {
                updatedCurPath = updatedCurPath.set(curSplicedPath.size - 1, updatedCurPath.get(curSplicedPath.size - 1) + 1);
            }
        });
        return updatedCurPath;
    });
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 722 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

Object.defineProperty(exports, "__esModule", {
    value: true
});

exports.default = function (content, moduleOptions) {
    if ((0, _EditorHelpers.isEmpty)(content) || (0, _EditorHelpers.isEmpty)(moduleOptions)) {
        var builderMode = (0, _getBuilderMode2.default)();
        return Immutable.Map({
            inner: Immutable.List(),
            title: 'Home',
            name: 'home',
            childModule: 'header_builder' === builderMode ? 'tatsu_header_row' : 'section',
            builderLayout: 'list'
        });
    }
    var parsedContent = Immutable.fromJS(content),
        parsedModuleOptions = Immutable.fromJS(moduleOptions, function (key, value) {
        if ('' === key) {
            return value.toOrderedMap();
        } else if (Immutable.Iterable.isIndexed(value)) {
            return value.toList();
        } else {
            return value.toMap();
        }
    });
    if ('undefined' != typeof parsedContent && 'undefined' != typeof parsedModuleOptions) {
        parsedContent = (0, _parseInitialState2.default)(parsedContent, parsedModuleOptions);
    }
    return parsedContent;
};

var _parseInitialState = __webpack_require__(373);

var _parseInitialState2 = _interopRequireDefault(_parseInitialState);

var _getBuilderMode = __webpack_require__(367);

var _getBuilderMode2 = _interopRequireDefault(_getBuilderMode);

var _EditorHelpers = __webpack_require__(26);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 723 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function convertToSlug(text) {

return text.toLowerCase().replace(/[^\w ]/g, '').replace(/ +/g, '-');
};

/***/ }),
/* 724 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Immutable) {

module.exports = function () {

var currentLocation = window.location.pathname,
        currentLocationArray = currentLocation.split("/"),
        pathIndex = -1 < currentLocation.indexOf('moduleEditor') ? currentLocationArray.length - 2 : -1 < currentLocation.indexOf('layoutManager') ? currentLocationArray.length - 1 : -1,
        modulePathString,
        modulePath = Immutable.List();
    if (-1 != pathIndex && '' != currentLocationArray[pathIndex]) {
        modulePathString = decodeURIComponent(currentLocationArray[pathIndex]);
        modulePath = Immutable.List(JSON.parse("[" + modulePathString + "]"));
    }
    return modulePath;
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))

/***/ }),
/* 725 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function (url) {

var newWindow = window.open(url, '_blank');
	if (newWindow) {
		window.focus();
	} else {
		alert('Please allow Popups for this site');
	}
};

/***/ }),
/* 726 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery, Immutable) {

var isEmpty = __webpack_require__(5);
var parseCustomField = __webpack_require__(38);

var Accordion = React.createClass({
    displayName: 'Accordion',

getInitialState: function getInitialState() {
        return {
            hover: false,
            hoverId: -1
        };
    },
    handleMouseEnter: function handleMouseEnter(id) {
        if (null != id) {
            this.setState({
                hover: true,
                hoverId: id
            });
        }
    },
    handleMouseLeave: function handleMouseLeave() {
        this.setState({
            hover: false,
            hoverId: -1
        });
    },
    render: function render() {
        var accordion = this.props.module,
            atts = accordion.get('atts'),
            children = accordion.get('inner'),
            cssObjectStyle = this.props.cssObject.style,
            gradientClass = this.props.cssObject.class,
            hover = this.state.hover,
            hoverId = this.state.hoverId;
        var style = 'style1',
            titleFont = '',
            contentFont = '',
            collapsed = '0',
            classes = [],
            visibilityClass = generateVisibilityClasses(atts);

if (!isEmpty(atts)) {
            titleFont = !isEmpty(atts.get('title_font')) ? atts.get('title_font') : titleFont;
            style = !isEmpty(atts.get('style')) ? atts.get('style') : style;
            contentFont = !isEmpty(atts.get('content_font')) ? atts.get('content_font') : contentFont;
            collapsed = !isEmpty(atts.get('collapsed')) ? atts.get('collapsed') : collapsed;
        }
        classes.push('tatsu-module', 'tatsu-accordion', 'tatsu-accordion-' + style, visibilityClass, atts.get('css_classes'));

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: classes.join(' '), style: jQuery.extend({}, cssObjectStyle['.tatsu-module'], cssObjectStyle['root']) }),
            React.createElement(
                'div',
                { className: 'tatsu-accordion-inner', 'data-collapsed': collapsed },
                Immutable.List.isList(children) && children.map(function (child) {
                    return [React.createElement(
                        'h3',
                        { onMouseEnter: this.handleMouseEnter.bind(null, child.get('id')),
                            onMouseLeave: this.handleMouseLeave,
                            className: "accordion-head " + ('' !== titleFont ? titleFont + ' ' : '') + gradientClass['.accordion-head'],
                            style: hover && hoverId === child.get('id') ? jQuery.extend({}, cssObjectStyle['.accordion-head'], cssObjectStyle['.accordion-head:hover'], cssObjectStyle['.accordion-head.ui-accordion-header']) : jQuery.extend({}, cssObjectStyle['.accordion-head'], cssObjectStyle['.accordion-head.ui-accordion-header'])
                        },
                        parseCustomField(child.getIn(['atts', 'title'])),
                        React.createElement('span', { className: 'tatsu-accordion-expand' })
                    ), React.createElement(
                        'div',
                        { className: "accordion-content " + ('' !== contentFont ? contentFont : ''), style: jQuery.extend({}, cssObjectStyle['.accordion-content'], cssObjectStyle['..accordion-content.ui-accordion-content']) },
                        React.createElement('div', { style: cssObjectStyle['.accordion-content-inner'], className: "accordion-content-inner" + (!isEmpty(atts.get('content_bg_color')) ? ' accordion-with-bg' : ''), dangerouslySetInnerHTML: { __html: 'default' != child.getIn(['atts', 'field_type']) ? parseCustomField(child.getIn(['atts', 'field_type'])) : parseCustomField(child.getIn(['atts', 'content'])) } })
                    )];
                }.bind(this))
            )
        );
    }
});

module.exports = Accordion;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4), __webpack_require__(3)))

/***/ }),
/* 727 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var parseCustomField = __webpack_require__(38),
    AnimatedHeading = React.createClass({
	displayName: 'AnimatedHeading',

getEffectMarkup: function getEffectMarkup() {
		var atts = this.props.module.get('atts'),
		    animeType = atts.get('anime_type'),
		    TagToUse = atts.get('tag_to_use'),
		    cssObject = this.props.cssObject.style,
		    text = parseCustomField(atts.get('text'));

switch (animeType) {
			case 'anime_top_bottom_lines':
				return React.createElement(
					'div',
					{ className: 'tatsu-animated-heading-inner-wrap' },
					React.createElement('span', { className: 'tatsu-animated-heading-line tatsu-animated-heading-line1', style: cssObject['.tatsu-animated-heading-line'] }),
					React.createElement(
						TagToUse,
						{ className: 'tatsu-animated-heading-inner', style: cssObject['.tatsu-animated-heading-inner'] },
						text
					),
					React.createElement('span', { className: 'tatsu-animated-heading-line tatsu-animated-heading-line2', style: cssObject['.tatsu-animated-heading-line'] })
				);
			case 'anime_slide_cursor':
			case 'anime_slide_underline':
				return React.createElement(
					'div',
					{ className: 'tatsu-animated-heading-inner-wrap' },
					React.createElement(
						TagToUse,
						{ className: 'tatsu-animated-heading-inner', style: cssObject['.tatsu-animated-heading-inner'] },
						text
					),
					React.createElement('span', { className: 'tatsu-animated-heading-line tatsu-animated-heading-line2', style: cssObject['.tatsu-animated-heading-line'] })
				);
			default:
				return React.createElement(
					TagToUse,
					{ className: 'tatsu-animated-heading-inner', style: cssObject['.tatsu-animated-heading-inner'] },
					text
				);
		}
	},

render: function render() {

var cssObject = this.props.cssObject.style,
		    atts = this.props.module.get('atts'),
		    animeType = atts.get('anime_type'),
		    animeDuration = atts.get('anime_duration'),
		    visibilityClass = generateVisibilityClasses(atts);

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-animated-heading-wrap " + ' ' + animeType + ' anime-duration-' + animeDuration + ' ' + visibilityClass + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-animated-heading-wrap'], cssObject['root']), 'data-anime-type': animeType, 'data-anime-duration': animeDuration }),
			this.getEffectMarkup.bind(this)()
		);
	}

});
module.exports = AnimatedHeading;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 728 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var isEmpty = __webpack_require__(5),
    parseCustomField = __webpack_require__(38),
    findDOMNode = ReactDOM.findDOMNode;

var AnimatedLink = React.createClass({
    displayName: 'AnimatedLink',

getInitialState: function getInitialState() {
        return { isMouseIn: false };
    },

hoverHandler: function hoverHandler() {
        this.setState({
            isMouseIn: !this.state.isMouseIn
        });
    },

componentDidMount: function componentDidMount() {
        var atts = this.props.module.get('atts');
        if (isEmpty(atts.get('alignment'))) {
            findDOMNode(this).parentElement.style.display = 'inline-block';
        } else {
            findDOMNode(this).parentElement.style.display = 'block';
        }
    },

componentDidUpdate: function componentDidUpdate() {
        var atts = this.props.module.get('atts');
        if (isEmpty(atts.get('alignment'))) {
            findDOMNode(this).parentElement.style.display = 'inline-block';
        } else {
            findDOMNode(this).parentElement.style.display = 'block';
        }
    },

render: function render() {
        var isMouseIn = this.state.isMouseIn,
            animatedLink = this.props.module,
            atts = animatedLink.get('atts');
        var linkText,
            url,
            fontSize,
            cssObject = this.props.cssObject.style,
            linkStyle,
            alignment,
            margin = '',
            color,
            hoverColor,
            lineColor,
            lineHoverColor;

lineColor = cssObject['.animated-link:before'] || {};
        lineHoverColor = cssObject['.animated-link:hover:before'];
        color = cssObject['.link-text'];
        margin = cssObject['.tatsu-module'];
        hoverColor = cssObject['.animated-link:hover .link-text'];
        if (this.state.isMouseIn) {
            lineColor = lineHoverColor;
            color = hoverColor;
        }
        fontSize = cssObject['a'];

if (!isEmpty(atts)) {
            linkText = parseCustomField(atts.get('link_text'));
            if (isEmpty(linkText)) {
                linkText = null;
            }
            url = parseCustomField(atts.get('url'));
            if (isEmpty(url)) {
                url = null;
            }
            linkStyle = atts.get('link_style');
            if (isEmpty(linkStyle)) {
                linkStyle = 'style1';
            }
            alignment = atts.get('alignment');
            if (isEmpty(alignment)) {
                alignment = 'none';
            }
        }
        return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: 'tatsu-animated-link tatsu-module tatsu-animated-link-align-' + alignment + ' tatsu-animated-link-' + linkStyle + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, margin, cssObject['root']) }),
            React.createElement(
                'a',
                { style: isMouseIn ? jQuery.extend({}, cssObject['.tatsu-animated-link-inner'], cssObject['.tatsu-animated-link-inner:hover']) : cssObject['.tatsu-animated-link-inner'], onMouseEnter: this.hoverHandler, onMouseLeave: this.hoverHandler, className: 'tatsu-animated-link-inner', href: url },
                'style4' !== linkStyle && React.createElement('span', { style: isMouseIn && 'style2' != linkStyle ? cssObject['.tatsu-animated-link-inner:hover::before'] : cssObject['.tatsu-animated-link-inner::before'], className: 'tatsu-animated-link-tatsu-before' }),
                React.createElement(
                    'span',
                    { style: 'style2' == linkStyle && isMouseIn ? cssObject['.tatsu-animated-link-inner:hover .tatsu-animated-link-text'] : null, className: 'tatsu-animated-link-text' },
                    linkText
                ),
                'style2' === linkStyle && React.createElement('span', { style: jQuery.extend({}, cssObject['.tatsu-animated-link-inner:hover .tatsu-animated-link-text'], cssObject['.tatsu-animated-link-inner::after']), className: 'tatsu-animated-link-tatsu-after' }),
                'style4' === linkStyle && React.createElement(
                    'span',
                    { className: 'tatsu-animated-link-arrow', style: isMouseIn ? cssObject['.tatsu-animated-link-inner:hover .tatsu-animated-link-arrow'] : cssObject['.tatsu-animated-link-arrow'] },
                    React.createElement(
                        'svg',
                        { xmlns: 'http://www.w3.org/2000/svg', xmlnsXlink: 'http://www.w3.org/1999/xlink', x: '0px', y: '0px', width: '25px', height: '15px', viewBox: '0 0 30 18', enableBackground: 'new 0 0 30 18', xmlSpace: 'preserve' },
                        React.createElement('path', { className: 'tatsu-svg-arrow-head', d: 'M20.305,16.212c-0.407,0.409-0.407,1.071,0,1.479s1.068,0.408,1.476,0l7.914-7.952c0.408-0.409,0.408-1.071,0-1.481\r l-7.914-7.952c-0.407-0.409-1.068-0.409-1.476,0s-0.407,1.071,0,1.48l7.185,7.221L20.305,16.212z' }),
                        React.createElement('path', { className: 'tatsu-svg-arrow-bar', fillRule: 'evenodd', clipRule: 'evenodd', d: 'M1,8h28.001c0.551,0,1,0.448,1,1c0,0.553-0.449,1-1,1H1c-0.553,0-1-0.447-1-1\r C0,8.448,0.447,8,1,8z' })
                    )
                )
            )
        );
    }
});

module.exports = AnimatedLink;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 729 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var parseValue = __webpack_require__(42),
    parseCustomField = __webpack_require__(38),
    findDOMNode = __webpack_require__(7).findDOMNode,
    isEmpty = __webpack_require__(5);
var AnimatedNumber = React.createClass({
	displayName: 'AnimatedNumber',

componentDidUpdate: function componentDidUpdate() {

var data = {
			type: 'jstrigger',
			moduleName: 'tatsu_animated_numbers',
			shouldUpdate: false
		},
		    jsonData = JSON.stringify(data);
		document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

if (this.props.module.getIn(['atts', 'number']) != nextProps.module.getIn(['atts', 'number']) && null !== this.animEle) {
			this.animEle.className += " animate";
		}
	},

addAnimRef: function addAnimRef(animEle) {
		this.animEle = animEle;
	},

render: function render() {

var animatedNumber = this.props.module,
		    moduleOptions = this.props.moduleOptions,
		    atts = animatedNumber.get('atts'),
		    number = '0',
		    prefix = parseCustomField(atts.get('prefix')),
		    suffix = parseCustomField(atts.get('suffix')),
		    caption = '',
		    alignment = '',
		    cssObject = this.props.cssObject.style,
		    gradientClass = this.props.cssObject.class,
		    numberStyle = cssObject['.tatsu-an'],
		    captionStyle = cssObject['.tatsu-an-caption'],
		    numberClass = gradientClass['.tatsu-an'],
		    prefixStyle = cssObject['.tatsu-an-prefix'],
		    prefixClass = gradientClass['.tatsu-an-prefix'],
		    suffixStyle = cssObject['.tatsu-an-suffix'],
		    suffixClass = gradientClass['.tatsu-an-suffix'],
		    captionClass = gradientClass['.tatsu-an-caption'],
		    visibilityClass = generateVisibilityClasses(atts);

if (!isEmpty(atts)) {
			number = parseValue(animatedNumber.get('name'), 'number', parseCustomField(atts.get('number')), moduleOptions, this.props.targetDisplay);
			caption = parseCustomField(atts.get('caption')), alignment = atts.get('alignment');
			if ('string' != typeof number || '' === number.replace(/\D+/, '')) {
				number = '0';
			}
			if (isEmpty(alignment)) {
				alignment = '';
			}
		}
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-an-wrap align-" + alignment + " " + visibilityClass, style: jQuery.extend({}, cssObject['.tatsu-an-wrap'], cssObject['root']) }),
			React.createElement(
				'div',
				{ className: 'tatsu-an-prefix-suffix-wrap' },
				'' !== prefix && React.createElement(
					'span',
					{ style: prefixStyle, className: "tatsu-an-prefix " + prefixClass },
					prefix
				),
				React.createElement('span', { ref: this.addAnimRef, className: "tatsu-an animate " + numberClass, style: numberStyle, 'data-number': number }),
				'' !== suffix && React.createElement(
					'span',
					{ style: suffixStyle, className: "tatsu-an-suffix " + suffixClass },
					suffix
				)
			),
			'' !== caption && React.createElement(
				'h6',
				null,
				React.createElement(
					'span',
					{ className: "tatsu-an-caption " + captionClass, style: captionStyle },
					caption
				)
			)
		);
	}

});
module.exports = AnimatedNumber;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 730 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses) {

var isEmpty = __webpack_require__(5);

var TatsuTestimonial = React.createClass({
	displayName: 'TatsuTestimonial',

render: function render() {

var tatsuTestimonial = this.props.module,
		    moduleOptions = this.props.moduleOptions,
		    atts = tatsuTestimonial.get('atts'),
		    description = '',
		    authorImage = '',
		    authorRole = '',
		    author = '',
		    alignment = '',
		    cssObject = this.props.cssObject.style,
		    gradientClass = this.props.cssObject.class;

if (!isEmpty(atts)) {
			alignment = atts.get('alignment');
			description = atts.get('description');
			authorImage = atts.get('author_image');
			author = atts.get('author');
			authorRole = atts.get('author_role');
		}

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu_testimonial_wrap clearfix bubble_" + alignment + ' ' + atts.get('css_classes') + ' ' + generateVisibilityClasses(atts), style: cssObject['root'] }),
			React.createElement(
				'div',
				{ className: 'tatsu_testimonial_wrap', style: cssObject['.tatsu_testimonial_wrap'] },
				React.createElement(
					'div',
					{ className: "tatsu_testimonial_inner_wrap " + gradientClass['.tatsu_testimonial_inner_wrap'], style: cssObject['.tatsu_testimonial_inner_wrap'] },
					React.createElement('i', { className: "tatsu-icon icon-quote " + gradientClass['.icon-quote'], style: cssObject['.icon-quote'] }),
					'' != description ? React.createElement(
						'div',
						{ className: "tatsu_testimonial_content", style: cssObject['.tatsu_testimonial_content'] },
						React.createElement(
							'div',
							{ className: "tatsu_testimonial_description " + gradientClass['.tatsu_testimonial_description'], style: cssObject['.tatsu_testimonial_description'] },
							description
						)
					) : null
				)
			),
			React.createElement(
				'div',
				{ className: 'tatsu_testimonial_info_wrap clearfix' },
				'' != authorImage ? React.createElement(
					'div',
					{ className: 'tatsu_testimonial_img' },
					React.createElement('img', { src: authorImage, alt: '' })
				) : null,
				React.createElement(
					'div',
					{ className: 'tatsu_testimonial_info' },
					['' === author || 'undefined' === typeof author ? null : React.createElement(
						'h6',
						{ className: "tatsu_testimonial_author " + gradientClass['.tatsu_testimonial_author'], style: cssObject['.tatsu_testimonial_author'] },
						' ',
						author,
						' '
					), '' === authorRole || 'undefined' === typeof authorRole ? null : React.createElement(
						'div',
						{ className: "tatsu_testimonial_role " + gradientClass['.tatsu_testimonial_role'], style: cssObject['.tatsu_testimonial_role'] },
						' ',
						authorRole
					)]
				)
			)
		);
	}

});
module.exports = TatsuTestimonial;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12)))

/***/ }),
/* 731 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, generateVisibilityClasses, generateIdentifierId, jQuery) {

var Button = __webpack_require__(380),
    isEmpty = __webpack_require__(5);
var ButtonGroup = React.createClass({
	displayName: 'ButtonGroup',

render: function render() {
		var buttonGroup = this.props.module,
		    moduleOptions = this.props.moduleOptions,
		    children = buttonGroup.get('inner') || Immutable.List(),
		    cssObject = this.props.cssObject,
		    atts = buttonGroup.get('atts'),
		    alignment = '',
		    visibilityClass = generateVisibilityClasses(atts),
		    cssUtilClasses = visibilityClass;

if (!isEmpty(atts)) {
			alignment = atts.get('alignment');
		}

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-Button-group align-" + alignment + " " + cssUtilClasses + " " + atts.get('css_classes'), style: jQuery.extend({}, cssObject.style['.tatsu-button-group'], cssObject.style['root']) }),
			children.map(function (button) {
				return React.createElement(Button, { key: button.get('id'), module: button, moduleOptions: moduleOptions, parentId: buttonGroup.get('id'), cssObject: cssObject, buttonGroup: true, targetDisplay: this.props.targetDisplay });
			}.bind(this))
		);
	}

});
module.exports = ButtonGroup;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 732 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateIdentifierId, generateVisibilityClasses) {

var isEmpty = __webpack_require__(5);
var parseCustomField = __webpack_require__(38);

var CallToAction = React.createClass({
	displayName: 'CallToAction',

getInitialState: function getInitialState() {
		return {
			hovered: false
		};
	},

hoverHandler: function hoverHandler() {
		this.setState({
			hovered: !this.state.hovered
		});
	},

render: function render() {

var callToAction = this.props.module,
		    moduleOptions = this.props.moduleOptions,
		    atts = callToAction.get('atts'),
		    wrapperClass = 'tatsu-module tatsu-call-to-action tatsu-shortcode clearfix ',
		    buttonStyle = {},
		    buttonHoverStyle = {},
		    actionTitle = '',
		    buttonText = '',
		    Actionvalue = 'h4',
		    lightbox = '',
		    newTab = '',
		    buttonImage = '',
		    buttonLink = '#',
		    buttonClass = 'mediumbtn tatsu-button rounded tatsu-action-button ',
		    cssObject = this.props.cssObject.style,
		    gradientClass = this.props.cssObject.class;

if (!isEmpty(atts)) {
			buttonText = parseCustomField(atts.get('button_text'));
			actionTitle = atts.get('title');
			Actionvalue = atts.get('h_tag');
			newTab = atts.get('new_tab');
			buttonLink = parseCustomField(atts.get('button_link'));
			lightbox = atts.get('lightbox');
			buttonImage = atts.get('image');

if ('default' != atts.get('field_type') && !isEmpty(atts.get('field_type'))) {
				actionTitle = parseCustomField(atts.get('field_type'));
			}

if (!isEmpty(newTab)) {
				newTab = '_blank';
			}

if (!isEmpty(lightbox)) {
				if ('undefined' != typeof buttonLink && '' != buttonLink) {
					buttonClass = buttonClass + 'mfp-iframe ';
				} else if (!isEmpty(buttonImage)) {
					buttonClass = buttonClass + 'mfp-image ';
					buttonLink = buttonImage;
				}
			}

buttonStyle = cssObject['.tatsu-action-button'];
			buttonHoverStyle = jQuery.extend({}, buttonStyle, cssObject['.tatsu-action-button:hover']);
		}
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: wrapperClass + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-call-to-action'], cssObject['root']) }),
			React.createElement(
				'div',
				{ className: 'tatsu-cta-inner' },
				React.createElement(
					Actionvalue,
					{ className: "tatsu-action-content " + gradientClass['.tatsu-action-content'], style: cssObject['.tatsu-action-content'] },
					' ',
					actionTitle,
					' '
				),
				!isEmpty(buttonLink) ? React.createElement(
					'a',
					{ className: buttonClass + (this.state.hovered ? gradientClass['.tatsu-action-button:hover'] : gradientClass['.tatsu-action-button']), href: buttonLink, target: !isEmpty(newTab) ? newTab : null, onMouseEnter: this.hoverHandler, onMouseLeave: this.hoverHandler, style: this.state.hovered ? buttonHoverStyle : buttonStyle },
					React.createElement(
						'span',
						{ className: this.state.hovered ? gradientClass['.tatsu-action-button:hover span'] : gradientClass['.tatsu-action-button span'], style: this.state.hovered ? cssObject['.tatsu-action-button:hover span'] : cssObject['.tatsu-action-button span'] },
						buttonText
					)
				) : null
			)
		);
	}

});
module.exports = CallToAction;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(15), __webpack_require__(12)))

/***/ }),
/* 733 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses) {

var isEmpty = __webpack_require__(5),
    findDOMNode = ReactDOM.findDOMNode,
    triggerScript = __webpack_require__(242);

var Code = React.createClass({
    displayName: 'Code',

componentDidUpdate: function componentDidUpdate() {

if (-1 < this.props.module.getIn(['atts', 'content']).indexOf('<script>')) {
            triggerScript(findDOMNode(this));
        }
    },

componentDidMount: function componentDidMount() {

if (-1 < this.props.module.getIn(['atts', 'content']).indexOf('<script>')) {
            triggerScript(findDOMNode(this));
        }
    },

render: function render() {

var code = this.props.module,
            moduleOptions = this.props.moduleOptions,
            atts = code.get('atts'),
            content,
            id,
            codeClass;

content = atts.get('content');
        if (isEmpty(content)) {
            content = '';
        }
        id = atts.get('id');
        if (isEmpty(id)) {
            id = 'small';
        }
        codeClass = atts.get('class');
        if (isEmpty(codeClass)) {
            codeClass = '';
        }
        var cssObject = this.props.cssObject;

return React.createElement('div', { id: id, className: 'tatsu-code tatsu-module ' + codeClass + ' ' + generateVisibilityClasses(atts), dangerouslySetInnerHTML: { __html: content }, style: cssObject.style['root'] });
    }

});

module.exports = Code;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12)))

/***/ }),
/* 734 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var Divider = React.createClass({
	displayName: 'Divider',

render: function render() {

var cssObject = this.props.cssObject.style,
		    atts = this.props.module.get('atts');
		var visibilityClass = generateVisibilityClasses(atts);

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-divider-wrap " + '' + visibilityClass + '' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-divider-wrap'], cssObject['root']) }),
			React.createElement('hr', { style: cssObject['.tatsu-divider'], className: 'tatsu-module tatsu-divider' })
		);
	}

});
module.exports = Divider;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 735 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5);

var Dropcap = React.createClass({
	displayName: 'Dropcap',

getDropcapClass: function getDropcapClass(atts) {

render: function render() {

var dropcap = this.props.module,
		    atts = dropcap.get('atts'),
		    moduleOptions = this.props.moduleOptions,
		    dropcapClass = '',
		    dropcapContent = '',
		    icon = '',
		    letter = '',
		    cssObject = this.props.cssObject.style,
		    gradientClass = this.props.cssObject.class;

var visibilityClass = generateVisibilityClasses(atts);

if (!isEmpty(atts)) {
			dropcapClass = this.getDropcapClass(atts);
			dropcapContent = atts.get('content');
			icon = atts.get('icon');
			letter = atts.get('letter');
		}

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: visibilityClass + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-dropcap-wrap'], cssObject['root']) }),
			React.createElement(
				'span',
				{ className: dropcapClass + gradientClass['.tatsu-dropcap'], style: cssObject['.tatsu-dropcap'] },
				!isEmpty(icon) ? React.createElement('i', { style: cssObject['.tatsu-icon'], className: icon + " tatsu-icon " + gradientClass['.tatsu-icon'] }) : React.createElement(
					'span',
					{ className: gradientClass['.tatsu-dropcap span'], style: cssObject['.tatsu-dropcap span'] },
					' ',
					letter,
					' '
				)
			),
			'undefined' != typeof dropcapContent ? React.createElement('div', { dangerouslySetInnerHTML: { __html: dropcapContent } }) : null
		);
	}

});
module.exports = Dropcap;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 736 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5),
    parseValue = __webpack_require__(42);
var Dropcap2 = React.createClass({
	displayName: 'Dropcap2',

getTitleTag: function getTitleTag(atts) {

var titleTag = 'div',
		    titleFont = atts.get('title_font');
		if (!isEmpty(titleFont) && 'body' != titleFont && 'special' != titleFont) {
			titleTag = titleFont;
		}
		return titleTag;
	},

getTitleClass: function getTitleClass(atts) {

render: function render() {

var dropcap = this.props.module,
		    moduleOptions = this.props.moduleOptions,
		    atts = dropcap.get('atts'),
		    titleColor = '',
		    commonStyle = {},
		    letter = '',
		    icon = '',
		    TitleTag = 'div',
		    titleClass = '',
		    visibilityClass = '',
		    title = '',
		    cssObject = this.props.cssObject.style,
		    gradientClass = this.props.cssObject.class;

if (!isEmpty(atts)) {
			icon = atts.get('icon');
			if ('' === icon || 'undefined' === typeof icon) {
				letter = atts.get('letter');
			}
			title = atts.get('dropcap_title');
			TitleTag = this.getTitleTag(atts);
			titleClass = this.getTitleClass(atts);
		}
		visibilityClass = generateVisibilityClasses(atts);

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-dropcap-wrap tatsu-module style2 " + atts.get('css_classes') + ' ' + visibilityClass, style: jQuery.extend({}, cssObject['.tatsu-dropcap-wrap'], cssObject['root']) }),
			'' != icon && 'undefined' != typeof icon ? React.createElement(
				'span',
				{ className: 'tatsu-dropcap' },
				React.createElement('i', { className: "font-icon " + icon + " " + gradientClass['.tatsu-icon'], style: cssObject['.tatsu-icon'] })
			) : React.createElement(
				'h6',
				{ className: "tatsu-dropcap " + gradientClass['.tatsu-dropcap'], style: cssObject['.tatsu-dropcap'] },
				letter
			),
			'undefined' != typeof title ? React.createElement(
				TitleTag,
				{ className: "tatsu-dropcap-title " + titleClass + ' ' + gradientClass['.tatsu-dropcap-title-color'], style: cssObject['.tatsu-dropcap-title-color'] },
				' ',
				title,
				' '
			) : null
		);
	}

});
module.exports = Dropcap2;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 737 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId) {

var parseValue = __webpack_require__(42),
    isEmpty = __webpack_require__(5);
var ExtraSpacing = React.createClass({
	displayName: 'ExtraSpacing',

getClass: function getClass(atts) {

render: function render() {

var lineBreak = this.props.module,
		    atts = this.props.atts,
		    cssObject = this.props.cssObject.style,
		    auxiliaryClass = '',
		    style = {};
		if (null != atts) {
			auxiliaryClass = this.getClass(atts);
		}

var visibilityClass = generateVisibilityClasses(atts);

return React.createElement('div', _extends({}, generateIdentifierId(atts), { className: "linebreak tatsu-module " + auxiliaryClass + visibilityClass + ' ' + atts.get('css_classes'), style: cssObject['.tatsu-empty-space'] }));
	}

});
module.exports = ExtraSpacing;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15)))

/***/ }),
/* 738 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateIdentifierId, generateVisibilityClasses) {

var mapChecker = __webpack_require__(16).mapChecker,
    findDOMNode = __webpack_require__(7).findDOMNode,
    isEmpty = __webpack_require__(5),
    getAttsBasedOnDisplay = __webpack_require__(53),
    parseCustomField = __webpack_require__(38),
    computeColorforCSS = __webpack_require__(94),
    parseValue = __webpack_require__(42);

var GradientButton = React.createClass({
	displayName: 'GradientButton',

triggerDisplayChange: false,

getInitialState: function getInitialState() {
		return {
			hovered: false
		};
	},

getWrapperClass: function getWrapperClass(atts) {

wrapperClass = wrapperClass + alignment;
		if (atts.get('hover_bg_color')) {
			wrapperClass = wrapperClass + " transparent_hover_bg";
		}
		return wrapperClass;
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

getButtonClass: function getButtonClass(atts) {

return buttonClass;
	},

componentDidMount: function componentDidMount() {

componentDidUpdate: function componentDidUpdate() {

hoverHandler: function hoverHandler() {
		this.setState({
			hovered: !this.state.hovered
		});
	},

render: function render(atts) {

var button = this.props.module,
		    moduleName = button.get('name'),
		    moduleOptions = this.props.moduleOptions,
		    attsFromModuleOptions = moduleOptions.getIn([moduleName, 'atts']),
		    atts = getAttsBasedOnDisplay(button.get('atts'), this.props.targetDisplay, attsFromModuleOptions),
		    deviceVisibility = atts.get('hide_in'),
		    cssObject = this.props.cssObject.style,
		    gradientClass = this.props.cssObject.class,
		    url = '',
		    newTab = '',
		    wrapperClass = '',
		    buttonClass = '',
		    buttonStyle = {},
		    buttonHoverStyle = {},
		    buttonTextStyle = {},
		    hoverEffect = atts.get('hover_effect'),
		    buttonTextClass = this.state.hovered ? gradientClass['.tatsu-button-text:after'] : gradientClass['.tatsu-button-text span'],
		    buttonBorderClass = this.state.hovered ? gradientClass['.tatsu-button-wrap:before'] : gradientClass['.tatsu-button-wrap:after'],
		    backgroundAnimation = '',
		    lightbox = '',
		    image = '',
		    buttonText = '',
		    alignmentButton = '',
		    wrapperStyle,

if (!isEmpty(atts)) {
			alignmentButton = atts.get('alignment');
			url = atts.get('url');
			image = atts.get('image');
			lightbox = atts.get('lightbox');
			if (!isEmpty(lightbox) && ('undefined' === typeof url || '' === url) && !isEmpty(image)) {
				url = image;
			}
			newTab = atts.get('new_tab');

wrapperClass = this.getWrapperClass(atts);
			buttonClass = this.getButtonClass(atts);
			buttonText = parseCustomField(atts.get('button_text'));
			if ('undefined' === typeof buttonText) {
				buttonText = '';
			}
		}

// if( !isEmpty( deviceVisibility ) ) {

//var buttonMargin = cssObject['.tatsu-button'];
		// Create Styling Objects from Module Options Array and Atts
		buttonStyle = jQuery.extend({}, cssObject[keyClass + '.tatsu-button:after'], cssObject[keyClass + '.tatsu-button-wrap:after'], cssObject[keyClass + '.tatsu-button'], cssObject[keyClass + '.tatsu-custom-button-size']);
		//buttonStyle = jQuery.extend( {}, cssObject[keyClass + '.tatsu-button:after'], cssObject[keyClass + '.tatsu-button-wrap:after'], buttonMargin );
		buttonStyle.borderStyle = "solid";
		buttonHoverStyle = jQuery.extend({}, buttonStyle, cssObject[keyClass + '.tatsu-button:before'], cssObject[keyClass + '.tatsu-button-wrap:before']);

buttonTextStyle = this.state.hovered ? cssObject[keyClass + '.tatsu-button-text:after'] : cssObject[keyClass + '.tatsu-button-text span'];
		buttonTextStyle = jQuery.extend({}, buttonTextStyle, cssObject[keyClass + '.tatsu-button-text']);
		//buttonStyle = jQuery.extend( {} , buttonStyle, cssObject[keyClass + '.tatsu-button:hover'] );

wrapperStyle = alignmentButton == 'none' ? cssObject[keyClassNoSpace + '.tatsu-gradient-button'] : cssObject[keyClassNoSpace + '.tatsu-button-container'];
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: wrapperClass + ' ' + key + ' ' + hoverEffect + ' ' + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, wrapperStyle, cssObject['root']) }),
			React.createElement(
				'div',
				{ className: "tatsu-button-wrap " },
				React.createElement(
					'a',
					{ className: buttonClass + " " + buttonBorderClass, onMouseEnter: this.hoverHandler, onMouseLeave: this.hoverHandler, style: this.state.hovered ? buttonHoverStyle : buttonStyle, target: newTab ? '_blank' : null, href: url },
					React.createElement(
						'span',
						{ className: 'tatsu-button-text' },
						React.createElement(
							'span',
							{ className: "default " + buttonTextClass, style: buttonTextStyle },
							' ',
							buttonText,
							' '
						)
					)
				)
			)
		);
	}
});
module.exports = GradientButton;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(15), __webpack_require__(12)))

/***/ }),
/* 739 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateIdentifierId, generateVisibilityClasses) {

var parseValue = __webpack_require__(42),
    findDOMNode = __webpack_require__(7).findDOMNode,
    isEmpty = __webpack_require__(5);
var GradientIcon = React.createClass({
	displayName: 'GradientIcon',

getInitialState: function getInitialState() {
		return {
			hovered: false
		};
	},

onHover: function onHover() {
		this.setState({
			hovered: !this.state.hovered
		});
	},

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

getAnchorClass: function getAnchorClass(atts, href) {

var anchorClass = '',
		    style = atts.get('style'),
		    size = atts.get('size'),
		    lightbox = atts.get('lightbox'),
		    image = atts.get('image');

if (!isEmpty(style)) {
			anchorClass = anchorClass + style + ' ';
		}
		if (!isEmpty(size)) {
			anchorClass = anchorClass + size + ' ';
		}
		if (!isEmpty(lightbox)) {
			if (!isEmpty(href)) {
				anchorClass = anchorClass + 'mfp-iframe ';
			} else if (!isEmpty(image)) {
				anchorClass = anchorClass + 'mfp-image ';
			}
		}
		return anchorClass;
	},

getIconClass: function getIconClass(atts) {

var iconClass = '',
		    name = atts.get('name');
		if (!isEmpty(name)) {
			iconClass = iconClass + name + ' ';
		}
		return iconClass;
	},

componentDidMount: function componentDidMount() {

componentDidUpdate: function componentDidUpdate() {

render: function render() {

var icon = this.props.module,
		    hasParent = this.props.hasParent || false,
		    id = hasParent ? "." + icon.get('id') + " " : "",
		    moduleOptions = this.props.moduleOptions,
		    atts = icon.get('atts'),
		    outerDivClass = '',
		    hrefValue = '#',
		    color = atts.get('color'),
		    hoverColor = atts.get('hover_color'),
		    style = atts.get('style'),
		    bgColor,
		    hoverBgColor,
		    borderColor,
		    iconStyleAtts = atts.get('style'),
		    hoverBorderColor,
		    anchorAttributes = {},
		    newTab = atts.get('new_tab'),
		    alignmentFromAtts = atts.get('alignment'),
		    cssObject = this.props.cssObject.style,
		    hover_effect_parent_class = alignmentFromAtts === 'none' && 'none' != atts.get('hover_effect') ? atts.get('hover_effect') : '',
		    hover_effect_child_class = alignmentFromAtts !== 'none' && 'none' != atts.get('hover_effect') ? atts.get('hover_effect') : '',
		    hrefFromAtts = atts.get('href'),
		    imageFromAtts = atts.get('image'),
		    anchorClass = this.getAnchorClass(atts, hrefFromAtts),
		    iconClass = this.getIconClass(atts),
		    gradientClass = this.props.cssObject.class,
		    iconBgStyle = jQuery.extend({}, cssObject[id + '.tatsu-icon-bg:after'], cssObject['a'], cssObject['.tatsu-icon-bg'], cssObject['.tatsu-custom-icon-bg']),
		    iconBgHoverStyle;

iconBgStyle.borderStyle = "solid";
		iconBgHoverStyle = jQuery.extend({}, iconBgStyle, cssObject[id + '.tatsu-icon-bg:hover'], cssObject[id + '.tatsu-icon-bg:before']);

if (!isEmpty(imageFromAtts)) {
			hrefValue = imageFromAtts;
		} else if (!isEmpty(hrefFromAtts)) {
			hrefValue = hrefFromAtts;
		}
		if (null != alignmentFromAtts) {
			outerDivClass = alignmentFromAtts;
		}
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-gradient-icon tatsu-icon-shortcode align-" + outerDivClass + ' ' + hover_effect_parent_class + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-gradient-icon'], cssObject['root']) }),
			React.createElement(
				'a',
				{ href: hrefValue, className: "tatsu-icon-bg icon-" + anchorClass + " " + gradientClass[id + '.tatsu-icon-bg:after'] + ' ' + iconStyleAtts + ' ' + hover_effect_child_class, style: this.state.hovered ? iconBgHoverStyle : iconBgStyle, onMouseEnter: this.onHover.bind(this), onMouseLeave: this.onHover.bind(this), target: !isEmpty(atts.get('new_tab')) ? '_blank' : null },
				React.createElement('i', { className: "tatsu-icon " + iconClass + " default " + gradientClass[id + '.tatsu-icon.default'], style: cssObject[id + '.tatsu-icon.default'] }),
				React.createElement('i', { className: "tatsu-icon " + iconClass + " hover " + gradientClass[id + '.tatsu-icon.hover'], style: cssObject[id + '.tatsu-icon.hover'] })
			)
		);
	}

});
module.exports = GradientIcon;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(15), __webpack_require__(12)))

/***/ }),
/* 740 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var isEmpty = __webpack_require__(5);

var GSectionMeta = React.createClass({
	displayName: 'GSectionMeta',

render: function render() {

var GSectionMeta = this.props.module,
		    alignment = '',
		    fontTitle = 'h6',
		    cssObject = this.props.cssObject,
		    metaPrefix = '',
		    atts = GSectionMeta.get('atts');
		if (!isEmpty(atts)) {
			alignment = atts.get('alignment');
			if (isEmpty(alignment)) {
				alignment = '';
			}

metaPrefix = atts.get('meta_prefix');
			if (isEmpty(metaPrefix)) {
				metaPrefix = '';
			}

fontTitle = atts.get('title_font');
			if (isEmpty(fontTitle)) {
				fontTitle = '';
			}
		}

return React.createElement(
			'div',
			{ style: cssObject.style['.tatsu-module'], className: "tatsu-module tatsu-gsection-meta align-" + alignment },
			React.createElement(
				'div',
				{ className: fontTitle },
				metaPrefix,
				' [META]'
			)
		);
	}
});
module.exports = GSectionMeta;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 741 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var isEmpty = __webpack_require__(5);

var GSectionTitle = React.createClass({
	displayName: 'GSectionTitle',

render: function render() {

var GSectionTitle = this.props.module,
		    alignment = '',
		    fontTitle = 'h6',
		    TitleTag,
		    cssObject = this.props.cssObject,
		    atts = GSectionTitle.get('atts');
		if (!isEmpty(atts)) {
			alignment = atts.get('alignment');
			if (isEmpty(alignment)) {
				alignment = '';
			}

fontTitle = atts.get('title_font');
			if (isEmpty(fontTitle)) {
				fontTitle = '';
			}
			TitleTag = atts.get('tag_to_use');
			if (isEmpty(TitleTag)) {
				TitleTag = 'div';
			}
		}

return React.createElement(
			'div',
			{ style: cssObject.style['.tatsu-module'], className: "tatsu-module tatsu-gsection-title align-" + alignment },
			React.createElement(
				'div',
				{ className: fontTitle },
				' [TITLE]'
			)
		);
	}

});
module.exports = GSectionTitle;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 742 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery, generateVisibilityClasses) {

var isEmpty = __webpack_require__(5);

var HamburgerMenu = React.createClass({
	displayName: 'HamburgerMenu',

getInitialState: function getInitialState() {
		return {
			hovered: false
		};
	},

hoverHandler: function hoverHandler() {
		this.setState({
			hovered: !this.state.hovered
		});
	},

render: function render() {

var children = this.props.module.get('inner') || Immutable.List(),
		    key = this.props.module.get('id'),
		    props = this.props,
		    modulePath,
		    pathFromSelectionState,
		    hamburgerMenu = this.props.module,
		    atts = hamburgerMenu.get('atts'),
		    HeaderColumn = __webpack_require__(151),
		    cssObject = this.props.cssObject.style,
		    menuLineStyle = cssObject['.tatsu-hamburger span'],
		    menuLineHoverStyle = cssObject['.tatsu-hamburger:hover span'];

return React.createElement(
			'div',
			{ id: "hamburger-" + key, style: jQuery.extend({}, cssObject['.tatsu-hamburger'], cssObject['root']), onMouseEnter: this.hoverHandler, onMouseLeave: this.hoverHandler, className: "hamburger-wrap tatsu-hamburger tatsu-header-module " + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes') },
			React.createElement(
				'div',
				{ className: 'tatsu-slide-menu', style: cssObject['.tatsu-slide-menu'] },
				React.createElement(
					'div',
					{ className: 'tatsu-slide-menu-inner' },
					children.map(function (headerColumn, index) {
						modulePath = props.path.push(index);
						pathFromSelectionState = props.pathFromSelectionState.push(index);
						return React.createElement(HeaderColumn, { pathFromSelectionState: pathFromSelectionState, dropEffect: props.dropEffect, key: headerColumn.get('id'), targetDisplay: props.targetDisplay, path: modulePath, column: headerColumn, parent: props.parent, moduleOptions: props.moduleOptions });
					})
				)
			),
			React.createElement(
				'div',
				{ className: 'line-wrapper' },
				React.createElement('span', { className: 'line-1', style: this.state.hovered ? menuLineHoverStyle : menuLineStyle }),
				React.createElement('span', { className: 'line-2', style: this.state.hovered ? menuLineHoverStyle : menuLineStyle }),
				React.createElement('span', { className: 'line-3', style: this.state.hovered ? menuLineHoverStyle : menuLineStyle })
			)
		);
	}

});
module.exports = HamburgerMenu;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4), __webpack_require__(12)))

/***/ }),
/* 743 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React) {

var computeColorforCSS = __webpack_require__(94),
    isEmpty = __webpack_require__(5);

var HeaderCart = React.createClass({
    displayName: 'HeaderCart',

render: function render() {

var cartModule = this.props.module,
            atts = cartModule.get('atts'),
            deviceVisibility = atts.get('hide_in'),
            strokeColor = computeColorforCSS(atts.get('icon_color')).color,
            cssObject = this.props.cssObject.style,
            visibilityClass = ' ',
            visibilityArray;

if (!isEmpty(deviceVisibility)) {

return React.createElement(
            'div',
            { className: "tatsu-header-module tatsu-cart" + visibilityClass, style: cssObject['.tatsu-cart'] },
            React.createElement(
                'svg',
                { xmlns: 'http://www.w3.org/2000/svg', width: '23', height: '29', viewBox: '0 0 23 29' },
                React.createElement(
                    'g',
                    { fill: 'none', fillRule: 'evenodd', stroke: strokeColor, strokeWidth: '2', transform: 'translate(0 1)' },
                    React.createElement('path', { d: 'M3.62646846,7 C3.10637982,7 2.67311371,7.3986624 2.6299227,7.91695452 L1.19737474,25.1075301 C1.1950729,25.1351521 1.19392049,25.1628579 1.19392049,25.1905756 C1.19392049,25.7428603 1.64163574,26.1905756 2.19392049,26.1905756 L20.8031792,26.1905756 C20.8308969,26.1905756 20.8586027,26.1894232 20.8862247,26.1871213 C21.4366017,26.1412566 21.8455897,25.6579071 21.7997249,25.1075301 L20.367177,7.91695452 C20.323986,7.3986624 19.8907199,7 19.3706312,7 L3.62646846,7 Z' }),
                    React.createElement('path', { 'stroke-linecap': 'round', d: 'M7,9.27272727 C6.49128382,3.09090909 7.99128382,4.33408493e-16 11.5,0 C15.0087162,0 16.5087162,3.09090909 16,9.27272727' })
                )
            )
        );
    }

});
module.exports = HeaderCart;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))

/***/ }),
/* 744 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var isEmpty = __webpack_require__(5);

var HeaderDivider = React.createClass({
	displayName: 'HeaderDivider',

render: function render() {

var cssObject = this.props.cssObject.style,
		    dividerModule = this.props.module,
		    atts = dividerModule.get('atts');

return React.createElement('div', _extends({}, generateIdentifierId(atts), { className: "tatsu-header-module tatsu-header-divider-wrap " + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-header-divider-wrap'], cssObject['root']) }));
	}

});
module.exports = HeaderDivider;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 745 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var isEmpty = __webpack_require__(5);

var HeaderLinks = React.createClass({
	displayName: 'HeaderLinks',

getInitialState: function getInitialState() {
		return {
			hovered: false
		};
	},

hoverHandler: function hoverHandler() {
		this.setState({
			hovered: !this.state.hovered
		});
	},

render: function render() {

var link = this.props.module,
		    atts = link.get('atts'),
		    cssObject = this.props.cssObject.style,
		    linkStyle = cssObject['.tatsu-link a'],
		    linkHoverStyle = cssObject['.tatsu-link a:hover'];
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-header-module tatsu-link " + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-link'], cssObject['root']) }),
			React.createElement(
				'a',
				{ href: atts.get('url'), target: atts.get('new_tab'), style: this.state.hovered ? linkHoverStyle : linkStyle },
				' ',
				atts.get('link_text')
			)
		);
	}

});
module.exports = HeaderLinks;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 746 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var isEmpty = __webpack_require__(5);

var HeaderLogo = React.createClass({
  displayName: 'HeaderLogo',

render: function render() {

var cssObject = this.props.cssObject.style,
        atts = this.props.atts;

return React.createElement(
      'div',
      _extends({}, generateIdentifierId(atts), { className: "tatsu-header-logo tatsu-header-module " + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-header-logo'], cssObject['root']) }),
      React.createElement(
        'a',
        { href: '#' },
        React.createElement('img', { src: atts.get('default'), className: 'logo-img default-logo', style: cssObject['.logo-img'] }),
        React.createElement('img', { src: atts.get('dark'), className: 'logo-img dark-logo', style: cssObject['.logo-img'] }),
        React.createElement('img', { src: atts.get('light'), className: 'logo-img light-logo', style: cssObject['.logo-img'] })
      )
    );
  }

});
module.exports = HeaderLogo;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 747 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var computeColorforCSS = __webpack_require__(94),
    isEmpty = __webpack_require__(5);

var HeaderSearch = React.createClass({
    displayName: 'HeaderSearch',

render: function render() {

var searchModule = this.props.module,
            atts = searchModule.get('atts'),
            strokeColor = computeColorforCSS(atts.get('icon_color')).color,
            cssObject = this.props.cssObject.style;

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: "tatsu-header-module tatsu-search " + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-search'], cssObject['root']) }),
            React.createElement(
                'svg',
                { xmlns: 'http://www.w3.org/2000/svg', width: '21', height: '21', viewBox: '0 0 21 21' },
                React.createElement(
                    'g',
                    { fill: 'none', fillRule: 'evenodd', stroke: strokeColor, strokeWidth: '2', transform: 'rotate(-45 9.27 7.257)' },
                    React.createElement('circle', { cx: '7.846', cy: '7.846', r: '6.846' }),
                    React.createElement('path', { 'stroke-linecap': 'round', d: 'M8.02203654,14.7239099 L8.02203654,23.1736574' })
                )
            )
        );
    }

});
module.exports = HeaderSearch;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 748 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5),
    parseCustomField = __webpack_require__(38),
    Vivus = __webpack_require__(200);
var IconCard = React.createClass({
    displayName: 'IconCard',

svgParent: null,

triggerLineAnimte: function triggerLineAnimte() {
        var atts = this.props.module.get('atts'),
            svgIcon = atts.get('svg_icon'),
            lineAnimate = atts.get('line_animate');
        var svgIconNameFamilyArray = [],
            svgIconFamily = '',
            svgIconPath = '',
            svgParent = this.svgParent,
            svgIconName = '';
        if ('All:' != svgIcon && !isEmpty(svgIcon) && null != tatsuSvgs) {
            svgIconNameFamilyArray = svgIcon.split(":");
            if (0 < svgIconNameFamilyArray.length) {
                svgIconFamily = svgIconNameFamilyArray[0];
                svgIconName = svgIconNameFamilyArray[1];
                if (null != tatsuSvgs[svgIconFamily] && '' != svgIconName) {
                    svgParent.innerHTML = "";
                    svgIconPath = tatsuSvgs[svgIconFamily].link + svgIconName + '.svg';
                    new Vivus(svgParent, { start: 'autostart', duration: isEmpty(lineAnimate) ? 1 : 50, file: svgIconPath, onReady: function onReady(e) {
                            svgParent.classList.add('tatsu-line-animate-ready');
                            e.play();
                        } });
                }
            }
        }
    },
    componentDidMount: function componentDidMount() {
        var atts = this.props.module.get('atts'),
            iconType = atts.get('icon_type');
        if ('svg' == iconType) {
            this.triggerLineAnimte();
        }
    },
    componentDidUpdate: function componentDidUpdate(prevProps) {
        var prevAtts = prevProps.module.get('atts'),
            curAtts = this.props.module.get('atts'),
            prevIconType = prevAtts.get('icon_type'),
            curIconType = curAtts.get('icon_type');
        var curIcon,
            prevLineAnimate = '',
            curLineAnimate = '',
            prevIcon;
        if ('svg' != prevIconType && 'svg' == curIconType) {
            this.triggerLineAnimte();
        } else if ('svg' == prevIconType && 'svg' == curIconType) {
            curIcon = curAtts.get('svg_icon');
            prevIcon = prevAtts.get('svg_icon');
            curLineAnimate = curAtts.get('line_animate');
            prevLineAnimate = prevAtts.get('line_animate');
            if (curIcon != prevIcon) {
                this.triggerLineAnimte();
            } else if (prevLineAnimate != curLineAnimate) {
                this.triggerLineAnimte();
            }
        }
    },
    render: function render() {
        var iconCard = this.props.module,
            atts = iconCard.get('atts'),
            deviceVisibility = atts.get('hide_in'),
            cssObject = this.props.cssObject;
        var classes = ['tatsu-icon_card', 'tatsu-module'],
            style = '',
            iconType = '',
            verticalAlignment = '',
            horizontalAlignment = '',
            iconStyle = '',
            title = '',
            titleFont = '',
            caption = '',
            captionFont = '',
            url = '',
            size = '';
        if (!isEmpty(atts)) {
            style = !isEmpty(atts.get('style')) ? atts.get('style') : 'style1';
            classes.push('tatsu-icon_card-' + style);
            if ('style1' == style) {
                verticalAlignment = atts.get('vertical_alignment');
                if (!isEmpty(verticalAlignment)) {
                    classes.push('tatsu-icon_card-vertical-align-' + verticalAlignment);
                } else {
                    classes.push('tatsu-icon_card-vertical-align-center');
                }
            }
            horizontalAlignment = atts.get('horizontal_alignment');
            if (!isEmpty(horizontalAlignment)) {
                classes.push('tatsu-icon_card-align-' + horizontalAlignment);
            } else {
                classes.push('tatsu-icon_card-align-center');
            }
            iconType = !isEmpty(atts.get('icon_type')) ? atts.get('icon_type') : 'icon';
            classes.push('tatsu-icon_card-type-' + iconType);
            iconStyle = !isEmpty(atts.get('icon_style')) ? atts.get('icon_style') : 'plain';
            if ('image' != iconType && 'circled' == iconStyle) {
                classes.push('tatsu-icon_circled');
            }
            if ('svg' === iconType && !isEmpty(atts.get('line_animate'))) {
                classes.push('tatsu-line-animate');
            }
            title = parseCustomField(atts.get('title'));
            caption = parseCustomField(atts.get('content'));
            size = atts.get('size');
            if (!isEmpty(size)) {
                classes.push('tatsu-icon_' + size);
            } else {
                classes.push('tatsu-icon_medium');
            }
            if (!isEmpty(atts.get('title_font'))) {
                titleFont = atts.get('title_font');
            }
            if (!isEmpty(atts.get('url'))) {
                url = parseCustomField(atts.get('url'));
            }
            if (!isEmpty(atts.get('caption_font'))) {
                captionFont = atts.get('caption_font');
            }
            if (!isEmpty(atts.get('hide_in'))) {
                classes.push(generateVisibilityClasses(atts));
            }
            if (!isEmpty(atts.get('css_classes'))) {
                classes.push(atts.get('css_classes'));
            }
        }
        return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: classes.join(' '), style: jQuery.extend({}, cssObject.style['.tatsu-module'], cssObject.style['root']) }),
            ('icon' === iconType && !isEmpty(atts.get('icon')) || 'svg' === iconType && 'All:' !== atts.get('svg_icon') || 'image' === iconType && !isEmpty(atts.get('image'))) && React.createElement(
                'div',
                { style: jQuery.extend({}, cssObject.style['.tatsu-icon_card-icon'], cssObject.style['.tatsu-icon_bg']), className: "tatsu-icon_card-icon " + cssObject.class['.tatsu-icon_bg'] + ' ' + cssObject.class['.tatsu-icon_card-icon'] + ('circled' === iconStyle && 'image' !== iconType ? ' tatsu-icon_bg' : 'plain' === iconStyle && 'image' === iconType ? 'tatsu-img-plain' : '') },
                ['icon' == iconType ? React.createElement('i', { style: cssObject.style['.tatsu-icon'], className: "tatsu-icon " + (!isEmpty(atts.get('icon')) ? atts.get('icon') : '') + ' ' + cssObject.class['.tatsu-icon'] }) : null, 'svg' == iconType ? React.createElement('div', { ref: function (curEle) {
                        this.svgParent = curEle;
                    }.bind(this), className: 'tatsu-svg-holder', style: cssObject.style['.tatsu-icon_card-icon svg'], dangerouslySetInnerHTML: { __html: '' } }) : null]
            ),
            ('' != title || '' != caption) && React.createElement(
                'div',
                { className: 'tatsu-icon_card-title-caption' },
                '' != title && React.createElement(
                    'div',
                    { style: cssObject.style['.tatsu-icon_card-title'], className: "tatsu-icon_card-title " + titleFont + ' ' + cssObject.class['.tatsu-icon_card-title'] },
                    React.createElement(
                        'a',
                        { href: url },
                        title
                    )
                ),
                '' != caption && React.createElement('div', { style: cssObject.style['.tatsu-icon_card-caption'], className: "tatsu-icon_card-caption " + captionFont + ' ' + cssObject.class['.tatsu-icon_card-caption'], dangerouslySetInnerHTML: { __html: caption } })
            )
        );
    }
});
module.exports = IconCard;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 749 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, generateVisibilityClasses, generateIdentifierId, jQuery) {

var Icon = __webpack_require__(381),
    isEmpty = __webpack_require__(5);
var IconGroup = React.createClass({
	displayName: 'IconGroup',

render: function render() {

var iconGroup = this.props.module,
		    moduleOptions = this.props.moduleOptions,
		    children = iconGroup.get('inner') || Immutable.List(),
		    atts = iconGroup.get('atts'),
		    deviceVisibility = atts.get('hide_in'),
		    alignment = '',
		    cssObject = this.props.cssObject,
		    cssObjectStyle = cssObject.style,
		    visibilityClass = ' ',
		    visibilityArray;

if (!isEmpty(atts)) {
			alignment = atts.get('alignment');
		}
		if (!isEmpty(deviceVisibility)) {

visibilityArray = deviceVisibility.split(',');
			visibilityArray.forEach(function (device, index) {
				visibilityClass = visibilityClass + 'tatsu-hide-' + device + ' ';
			});
		} else {
			visibilityClass = generateVisibilityClasses(atts);
		}
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-icon-group align-" + alignment + visibilityClass, style: jQuery.extend({}, cssObjectStyle['.tatsu-icon-group'], cssObjectStyle['root']) }),
			children.map(function (icon) {
				return React.createElement(Icon, { key: icon.get('id'), module: icon, moduleOptions: moduleOptions, parentId: iconGroup.get('id'), cssObject: cssObject, hasParent: true, iconGroup: true });
			})
		);
	}

});
module.exports = IconGroup;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 750 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateVisibilityClasses, generateIdentifierId) {

/**
 * Interactive slider with slick.
 * @issues : https://github.com/akiran/react-slick/issues/1241
 */
var isEmpty = __webpack_require__(5),
    findDOMNode = ReactDOM.findDOMNode,
    PrevArrow = __webpack_require__(157).PrevArrow,
    NextArrow = __webpack_require__(157).NextArrow,
    Slider = ReactSlick.default;

var TatsuImageCarousel = React.createClass({
    displayName: 'TatsuImageCarousel',

autoPlayTimer: null,

clearCustomAutoplay: function clearCustomAutoplay() {
        if (null != this.autoPlayTimer) {
            clearInterval(this.autoPlayTimer);
            this.autoPlayTimer = null;
        }
    },

customAutoplay: function customAutoplay() {
        var carousel = this.props.module,
            autoPlaySpeed = parseInt(carousel.getIn(['atts', 'slide_show_speed'])) || 1000;
        this.clearCustomAutoplay();
        this.autoPlayTimer = setInterval(function () {
            this.slider.slickNext();
        }.bind(this), autoPlaySpeed);
    },

componentDidMount: function componentDidMount() {
        var carousel = this.props.module;
        if (null != carousel.get('atts') && !isEmpty(carousel.getIn(['atts', 'slide_show']))) {
            this.customAutoplay();
        }
    },

getWindowWidth: function getWindowWidth() {
        var targetDoc = document.getElementById('tatsu-preview'),
            winWidth = null;
        if (null != targetDoc) {
            winWidth = targetDoc.contentWindow.innerWidth;
        }
        return winWidth;
    },

buildResponsiveSettings: function buildResponsiveSettings(settings) {
        if ('object' == (typeof settings === 'undefined' ? 'undefined' : _typeof(settings))) {
            var sliderType = this.props.module.getIn(['atts', 'type']),
                winWidth = this.getWindowWidth();
            if (null != winWidth) {
                if (1024 > winWidth && 768 <= winWidth) {
                    if ('fixed' === sliderType && 2 < settings.slidesToShow) {
                        settings.slidesToShow = 2;
                    }
                } else if (768 > winWidth) {
                    if (settings.hasOwnProperty('slidesToShow')) {
                        if ('client_carousel' === sliderType) {
                            settings.slidesToShow = 2;
                        } else {
                            settings.slidesToShow = 1;
                        }
                    }
                    if (settings.hasOwnProperty('variableWidth')) {
                        settings.variableWidth = false;
                        if ('ribbon' == sliderType || 'centered_ribbon' == sliderType) {
                            settings.adaptiveHeight = true;
                        }
                    }
                    if (settings.hasOwnProperty('centerMode')) {
                        settings.centerMode = false;
                    }
                }
            }
        }
    },

triggerReflow: function triggerReflow() {
        var curSlider = findDOMNode(this.slider),
            slides;
        if (null != curSlider) {
            slides = jQuery(curSlider).find('.tatsu-carousel-col-inner');
            if (0 < slides.length) {
                slides.css('top', '0');
                slides[0].offsetLeft;
                slides.css('top', '');
            }
        }
    },

clearAdaptiveHeight: function clearAdaptiveHeight() {
        var curSlider = findDOMNode(this.slider),
            list;
        if (null != curSlider) {
            list = jQuery(curSlider).find('.slick-list');
            if (0 < list.length) {
                if (isEmpty(this.slider.props.adaptiveHeight) && '' !== list[0].style.height) {
                    list.css('height', '');
                }
            }
        }
    },

componentDidUpdate: function componentDidUpdate(prevProps) {
        var currentCarousel = this.props.module,
            oldCarousel = prevProps.module,
            curAutoPlay = currentCarousel.getIn(['atts', 'slide_show']),
            oldAutoPlay = oldCarousel.getIn(['atts', 'slide_show']),
            curAutoPlaySpeed = currentCarousel.getIn(['atts', 'slide_show_speed']),
            oldAutoPlaySpeed = oldCarousel.getIn(['atts', 'slide_show_speed']);
        if (!isEmpty(oldAutoPlay) && isEmpty(curAutoPlay)) {
            this.clearCustomAutoplay();
        } else if (isEmpty(oldAutoPlay) && !isEmpty(curAutoPlay)) {
            this.customAutoplay();
        } else if (curAutoPlay && oldAutoPlay && oldAutoPlaySpeed != curAutoPlaySpeed) {
            this.customAutoplay();
        }
        this.triggerReflow();
        this.clearAdaptiveHeight();
    },

getSlideStyle: function getSlideStyle() {
        var atts = this.props.module.get('atts'),
            gutter = Number(atts.get('slide_gutter')) || 0;
        return {
            padding: '0 ' + gutter / 2 + 'px'
        };
    },

getSlideInnerStyle: function getSlideInnerStyle() {
        var cssObject = this.props.cssObject.style,
            slideInnerStyle = {},
            targetDoc = null,
            atts = this.props.atts;
        slideInnerStyle = cssObject['.tatsu-carousel-col-inner'] || {};
        if (!isEmpty(atts.get('full_screen'))) {
            targetDoc = document.getElementById('tatsu-preview');
            if (null != targetDoc && 'object' == (typeof slideInnerStyle === 'undefined' ? 'undefined' : _typeof(slideInnerStyle))) {
                slideInnerStyle.height = targetDoc.contentWindow.innerHeight;
            }
        }
        return slideInnerStyle;
    },

renderSlides: function renderSlides(urlArray) {
        return urlArray.map(function (url) {
            return React.createElement(
                'div',
                null,
                React.createElement(
                    'div',
                    { className: 'tatsu-media-slide tatsu-carousel-col', style: this.getSlideStyle() },
                    React.createElement(
                        'div',
                        { className: 'tatsu-media-slide-inner tatsu-carousel-col-inner', style: this.getSlideInnerStyle() },
                        React.createElement('img', { className: 'tatsu-carousel-img', src: url })
                    )
                )
            );
        }.bind(this));
    },

render: function render() {
        var imageCarousel = this.props.module,
            sliderSettings = {},
            carouselStyle = '',
            slidesToShow = 3,
            cssObject = this.props.cssObject.style,
            gutter = '',
            images = '',
            destroyInMobile = false,
            idAndUrl = [],
            urlArray = [],
            winWidth = this.getWindowWidth(),
            wrapperClasses = ['tatsu-media-carousel', 'clearfix', 'tatsu-module'],
            classArray = ['tatsu-media-carousel-inner', 'tatsu-carousel'],
            atts = imageCarousel.get('atts');

if (!isEmpty(atts)) {
            carouselStyle = atts.get('type') || 'ribbon';
            gutter = Number(atts.get('slide_gutter')) || 0;
            if (!isEmpty(atts.get('arrows'))) {
                sliderSettings.arrows = true;
                sliderSettings.prevArrow = React.createElement(PrevArrow, null);
                sliderSettings.nextArrow = React.createElement(NextArrow, null);
            } else {
                sliderSettings.arrows = false;
            }

if (!isEmpty(atts.get('css_classes'))) {
                wrapperClasses.push(atts.get('css_classes'));
            }
            wrapperClasses.push(generateVisibilityClasses(atts));

if (!isEmpty(atts.get('infinite'))) {
                sliderSettings.infinite = true;
            } else {
                sliderSettings.infinite = false;
            }

if (!isEmpty(atts.get('pagination'))) {
                sliderSettings.dots = true;
                classArray.push('slick-dotted');
                sliderSettings.appendDots = function (dots) {
                    dots = React.Children.map(dots, function (ele) {
                        return React.createElement('li', { className: ele.props.className,
                            style: 'slick-active' == ele.props.className && null != cssObject['.flickity-page-dots .is-selected'] ? cssObject['.flickity-page-dots .is-selected'] : null
                        });
                    });
                    return React.createElement(
                        'ul',
                        { margin: { margin: '0px' } },
                        ' ',
                        dots,
                        ' '
                    );
                };
            } else {
                sliderSettings.dots = false;
            }
            if (!isEmpty(atts.get('swipe_to_slide')) && '1' === atts.get('swipe_to_slide')) {
                sliderSettings.swipeToSlide = true;
            } else {
                sliderSettings.swipeToSlide = false;
            }

images = atts.get('images');
            idAndUrl = images.split(',');
            if (!isEmpty(idAndUrl)) {
                urlArray = idAndUrl.map(function (idAndUrlData) {
                    return idAndUrlData.split('::')[1];
                });
            }

if (!isEmpty(atts.get('destroy_in_mobile'))) {
                destroyInMobile = true;
                classArray.push('tatsu-carousel-destroy-in-mobile');
            }

slidesToShow = parseInt(atts.get('slides_to_show')) || 3;
            slidesToShow = slidesToShow > idAndUrl.length ? idAndUrl.length : slidesToShow;
            if (('fixed' == carouselStyle || 'client_carousel' == carouselStyle) && 0 < slidesToShow) {
                sliderSettings.slidesToShow = slidesToShow;
            } else {
                sliderSettings.variableWidth = true;
                if ('centered_ribbon' == carouselStyle) {
                    sliderSettings.centerMode = true;
                }
            }
            if ('fixed' == carouselStyle) {
                classArray.push('tatsu-fixed-carousel');
                if ('1' == atts.get('center_scale')) {
                    classArray.push('tatsu-image-center-scale');
                }
            } else if ('client_carousel' == carouselStyle) {
                classArray.push('tatsu-client-carousel');
            } else {
                classArray.push('tatsu-variable-carousel');
            }
            if (!isEmpty(atts.get('full_screen'))) {
                classArray.push('tatsu-full-screen-carousel');
            }
            this.buildResponsiveSettings(sliderSettings);
        }

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: wrapperClasses.join(' '), style: jQuery.extend({}, cssObject['.tatsu-module'], cssObject['root']) }),
            React.createElement(
                'div',
                { className: classArray.join(' ') },
                null != winWidth && 768 > winWidth && destroyInMobile ? this.renderSlides(urlArray) : React.createElement(
                    Slider,
                    { variableWidth: sliderSettings.variableWidth ? true : false,
                        adaptiveHeight: sliderSettings.adaptiveHeight ? true : false,
                        infinite: sliderSettings.infinite ? true : false,
                        appendDots: sliderSettings.dots ? sliderSettings.appendDots : null,
                        arrows: sliderSettings.arrows ? true : false,
                        prevArrow: sliderSettings.arrows && sliderSettings.prevArrow ? sliderSettings.prevArrow : null,
                        nextArrow: sliderSettings.arrows && sliderSettings.nextArrow ? sliderSettings.nextArrow : null,
                        dots: sliderSettings.dots ? true : false,
                        swipeToSlide: sliderSettings.swipeToSlide ? true : false,
                        slidesToShow: sliderSettings.slidesToShow ? sliderSettings.slidesToShow : 1,
                        centerMode: sliderSettings.centerMode ? true : false,
                        ref: function (slider) {
                            this.slider = slider;
                        }.bind(this),
                        style: { margin: '0 -' + gutter / 2 + 'px' }

},
                    this.renderSlides(urlArray)
                )
            )
        );
    }
});
module.exports = TatsuImageCarousel;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(12), __webpack_require__(15)))

/***/ }),
/* 751 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports.tatsu_button = __webpack_require__(380);
module.exports.tatsu_text = __webpack_require__(772);
module.exports.tatsu_icon = __webpack_require__(381);
module.exports.tatsu_title_icon = __webpack_require__(773);
module.exports.tatsu_notifications = __webpack_require__(758);
module.exports.tatsu_dropcap = __webpack_require__(735);
module.exports.tatsu_dropcap2 = __webpack_require__(736);
module.exports.tatsu_call_to_action = __webpack_require__(732);
module.exports.tatsu_icon_group = __webpack_require__(749);
module.exports.tatsu_button_group = __webpack_require__(731);
module.exports.tatsu_video = __webpack_require__(775);
module.exports.tatsu_lists = __webpack_require__(755);
module.exports.tatsu_testimonial = __webpack_require__(730);
module.exports.tatsu_empty_space = __webpack_require__(737);
module.exports.tatsu_divider = __webpack_require__(734);
module.exports.tatsu_animated_numbers = __webpack_require__(729);
module.exports.tatsu_inline_text = __webpack_require__(752);
module.exports.simple_text = __webpack_require__(761);
module.exports.tatsu_image = __webpack_require__(762);
module.exports.tatsu_code = __webpack_require__(733);
module.exports.tatsu_gradient_icon = __webpack_require__(739);
module.exports.tatsu_gradient_button = __webpack_require__(738);
module.exports.tatsu_skills = __webpack_require__(764);
module.exports.tatsu_star_rating = __webpack_require__(766);
module.exports.tatsu_image_carousel = __webpack_require__(750);
module.exports.tatsu_svg_icon = __webpack_require__(767);
module.exports.tatsu_icon_card = __webpack_require__(748);
module.exports.tatsu_animated_link = __webpack_require__(728);
module.exports.tatsu_typed_text = __webpack_require__(774);
module.exports.tatsu_team = __webpack_require__(769);
module.exports.tatsu_tabs = __webpack_require__(768);
module.exports.tatsu_accordion = __webpack_require__(726);
module.exports.tatsu_special_heading = __webpack_require__(765);
module.exports.tatsu_interactive_box = __webpack_require__(753);
module.exports.tatsu_testimonials_carousel = __webpack_require__(771);
module.exports.tatsu_process = __webpack_require__(759);
module.exports.tatsu_multi_layer_images = __webpack_require__(757);
module.exports.tatsu_animated_heading = __webpack_require__(727);

// Header Modules
module.exports.tatsu_header_logo = __webpack_require__(746);
module.exports.tatsu_hamburger_menu = __webpack_require__(742);
module.exports.tatsu_header_divider = __webpack_require__(744);
module.exports.tatsu_header_links = __webpack_require__(745);
module.exports.tatsu_search = __webpack_require__(747);
module.exports.tatsu_cart = __webpack_require__(743);
module.exports.tatsu_gsection_title = __webpack_require__(741);
module.exports.tatsu_gsection_meta = __webpack_require__(740);

/***/ }),
/* 752 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, generateIdentifierId, generateVisibilityClasses, jQuery) {

var parseValue = __webpack_require__(42),
    Inlineinner = __webpack_require__(382),
    isEmpty = __webpack_require__(5),
    getConcatenatedCSS = __webpack_require__(67);
var InlineText = React.createClass({
    displayName: 'InlineText',

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var currentAtts = this.props.atts,
            newAtts = nextProps.atts;
        return !Immutable.is(currentAtts, newAtts);
    },

render: function render() {

});
module.exports = InlineText;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 753 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateVisibilityClasses, generateIdentifierId) {

var getSvgIconPath = __webpack_require__(240),
    isEmpty = __webpack_require__(5),
    Vivus = __webpack_require__(200);
var InteractiveBox = React.createClass({
    displayName: 'InteractiveBox',

svgParent: null,
    getInitialState: function getInitialState() {
        return {
            hover: false
        };
    },
    handleHover: function handleHover() {
        var curState = this.state.hover;
        this.setState({
            hover: !curState
        });
    },
    triggerLineAnimte: function triggerLineAnimte() {
        var atts = this.props.module.get('atts'),
            svgPath = getSvgIconPath(atts.get('svg_icon')),
            svgParent = this.svgParent;
        if (!isEmpty(svgPath) && null != svgParent) {
            svgParent.innerHTML = "";
            new Vivus(svgParent, {
                duration: 100,
                start: 'autostart',
                file: svgPath,
                onReady: function onReady(e) {
                    var svgEle = e.el;
                    svgEle.style.stroke = "inherit";
                    svgEle.style.width = "inherit";
                    svgEle.style.height = "inherit";
                    svgParent.classList.add('tatsu-line-animate-ready');
                    e.play();
                }
            });
        }
    },
    componentDidMount: function componentDidMount() {
        var atts = this.props.module.get('atts'),
            style = atts.get('style');
        if ('transform' == style) {
            this.triggerLineAnimte();
        }
    },
    componentDidUpdate: function componentDidUpdate(prevProps) {
        var prevAtts = prevProps.module.get('atts'),
            curAtts = this.props.module.get('atts'),
            prevStyle = prevAtts.get('style'),
            curStyle = curAtts.get('style'),
            curIcon,
            prevIcon;
        if ('transform' != prevStyle && 'transform' == curStyle) {
            this.triggerLineAnimte();
        } else if ('transform' == prevStyle && 'transform' == curStyle) {
            curIcon = curAtts.get('svg_icon');
            prevIcon = prevAtts.get('svg_icon');
            if (curIcon != prevIcon) {
                this.triggerLineAnimte();
            }
        }
    },
    getFlipHtml: function getFlipHtml(atts) {
        var overlayClass = !isEmpty(atts.get('overlay_color')) ? 'tatsu-interactive-box-overlay' : '',
            icon = !isEmpty(atts.get('icon')) ? atts.get('icon') : '',
            cssObject = this.props.cssObject.style,
            title = atts.get('title'),
            titleFont = !isEmpty(atts.get('title_font')) ? atts.get('title_font') : '',
            content = atts.get('content');
        return React.createElement(
            'div',
            { className: 'tatsu-interactive-box-flip-wrap' },
            React.createElement(
                'div',
                { className: "tatsu-interactive-box-front " + overlayClass, style: cssObject['.tatsu-interactive-box-front'] },
                !isEmpty(overlayClass) ? React.createElement('div', { className: 'tatsu-interactive-box-tatsu-overlay', style: cssObject['.tatsu-interactive-box-overlay::before'] }) : null,
                React.createElement(
                    'div',
                    { className: 'tatsu-interactive-box-header' },
                    React.createElement(
                        'div',
                        { className: 'tatsu-interactive-box-icon', style: cssObject['.tatsu-interactive-box-icon'] },
                        React.createElement('i', { className: "tatsu-icon " + icon })
                    ),
                    React.createElement(
                        'div',
                        { style: cssObject['.tatsu-interactive-box-title'], className: "tatsu-interactive-box-title " + titleFont },
                        title
                    )
                )
            ),
            React.createElement(
                'div',
                { className: "tatsu-interactive-box-back " + overlayClass, style: cssObject['.tatsu-interactive-box-back'] },
                !isEmpty(overlayClass) ? React.createElement('div', { className: 'tatsu-interactive-box-tatsu-overlay', style: cssObject['.tatsu-interactive-box-overlay::before'] }) : null,
                React.createElement('div', { style: cssObject['.tatsu-interactive-box-content'], className: 'tatsu-interactive-box-content', dangerouslySetInnerHTML: { __html: content } })
            )
        );
    },
    getStackedHtml: function getStackedHtml(atts) {
        var icon = !isEmpty(atts.get('icon')) ? atts.get('icon') : '',
            title = atts.get('title'),
            hover = this.state.hover,
            cssObject = this.props.cssObject.style,
            bgImage = !isEmpty(atts.get('bg_image')) ? atts.get('bg_image') : '',
            titleFont = !isEmpty(atts.get('title_font')) ? atts.get('title_font') : '',
            content = atts.get('content');
        return React.createElement(
            'div',
            { style: { borderRadius: 'inherit' } },
            !isEmpty(bgImage) ? React.createElement(
                'div',
                { className: 'tatsu-interactive-box-stacks', style: cssObject['.tatsu-interactive-box-stacks'] },
                React.createElement('div', { className: 'tatsu-interactive-box-stacks-before', style: cssObject['.tatsu-interactive-box-stacks::before'] }),
                React.createElement('div', { style: cssObject['.tatsu-interactive-box-image-holder'], className: 'tatsu-interactive-box-image-holder' }),
                React.createElement('div', { className: 'tatsu-interactive-box-stacks-after', style: cssObject['.tatsu-interactive-box-stacks::after'] })
            ) : React.createElement('div', { className: 'tatsu-interactive-box-stacks', style: cssObject['.tatsu-interactive-box-stacks'] }),
            React.createElement(
                'div',
                { className: 'tatsu-interactive-box-inner' },
                React.createElement(
                    'div',
                    { className: 'tatsu-interactive-box-header' },
                    React.createElement(
                        'div',
                        { className: 'tatsu-interactive-box-icon', style: hover ? jQuery.extend({}, cssObject['.tatsu-interactive-box-icon'], cssObject[':hover .tatsu-interactive-box-icon']) : cssObject['.tatsu-interactive-box-icon'] },
                        React.createElement('i', { className: "tatsu-icon " + icon })
                    ),
                    React.createElement(
                        'div',
                        { style: cssObject['.tatsu-interactive-box-title'], style: hover ? jQuery.extend({}, cssObject['.tatsu-interactive-box-title'], cssObject[':hover .tatsu-interactive-box-title']) : cssObject['.tatsu-interactive-box-title'], className: "tatsu-interactive-box-title " + titleFont },
                        title
                    )
                ),
                React.createElement('div', { style: hover ? jQuery.extend({}, cssObject['.tatsu-interactive-box-content'], cssObject[':hover .tatsu-interactive-box-content']) : cssObject['.tatsu-interactive-box-content'], className: 'tatsu-interactive-box-content', dangerouslySetInnerHTML: { __html: content } })
            )
        );
    },
    getTransformHtml: function getTransformHtml(atts) {
        var title = atts.get('title'),
            titleFont = !isEmpty(atts.get('title_font')) ? atts.get('title_font') : '',
            hover = this.state.hover,
            cssObject = this.props.cssObject.style,
            content = atts.get('content'),
            iconSize,
            transformVal,
            transformVal = '';
        if (this.state.hover) {
            iconSize = atts.get('icon_size');
            transformVal = !isNaN(parseInt(iconSize)) ? parseInt(iconSize) + 20 + 'px' : '';
        }
        return React.createElement(
            'div',
            { className: 'tatsu-interactive-box-inner' },
            React.createElement(
                'div',
                { className: 'tatsu-interactive-box-icon-content', style: { transform: '' != transformVal ? 'translateY(-' + transformVal + ')' : null } },
                'All:' !== atts.get('svg_icon') && React.createElement('div', { ref: function (ele) {
                        this.svgParent = ele;
                    }.bind(this), style: jQuery.extend({}, { display: 'inline-block' }, cssObject['.tatsu-interactive-box-icon svg']), className: 'tatsu-interactive-box-icon tatsu-line-animate', dangerouslySetInnerHTML: { __html: '' } }),
                React.createElement(
                    'div',
                    { style: hover ? jQuery.extend({}, cssObject['.tatsu-interactive-box-title'], cssObject[':hover .tatsu-interactive-box-title']) : cssObject['.tatsu-interactive-box-title'], className: "tatsu-interactive-box-title " + titleFont },
                    title
                ),
                React.createElement('div', { style: hover ? jQuery.extend({}, cssObject['.tatsu-interactive-box-content'], cssObject[':hover .tatsu-interactive-box-content']) : cssObject['.tatsu-interactive-box-content'], className: 'tatsu-interactive-box-content', dangerouslySetInnerHTML: { __html: content } })
            ),
            React.createElement(
                'div',
                { className: 'tatsu-interactive-box-arrow', style: cssObject['.tatsu-interactive-box-arrow'] },
                React.createElement(
                    'svg',
                    { style: cssObject['.tatsu-interactive-box-arrow svg'], xmlns: 'http://www.w3.org/2000/svg', viewBox: '0 0 43 29' },
                    React.createElement(
                        'g',
                        { fill: 'none', strokeLinecap: 'round', strokeWidth: '3', transform: 'translate(2 2)' },
                        React.createElement('path', { d: 'M0.106550075,12.6101838 L38.2937419,12.6101838' }),
                        React.createElement('polyline', { strokeLinejoin: 'round', points: '27.042 0 39.31 12.581 27.042 25.161' })
                    )
                )
            )
        );
    },
    render: function render() {
        var interactiveBox = this.props.module,
            cssObject = this.props.cssObject,
            atts = interactiveBox.get('atts'),
            classes = ['tatsu-interactive-box', 'tatsu-module'],
            url = '',
            style = '',
            alignment = '',
            bgImage = '',
            overlay = '',
            customHeight = '';
        if (!isEmpty(atts)) {
            url = !isEmpty(atts.get('url')) ? atts.get('url') : '';
            style = !isEmpty(atts.get('style')) ? atts.get('style') : 'stacked';
            alignment = !isEmpty(atts.get('alignment')) ? atts.get('alignment') : 'center';
            bgImage = !isEmpty(atts.get('bg_image')) ? atts.get('bg_image') : '';
            customHeight = !isEmpty(atts.get('height')) ? true : false;
            overlay = !isEmpty(atts.get('overlay_color')) ? true : false;
            if (!isEmpty(alignment)) {
                classes.push('tatsu-interactive-box-align-' + alignment);
            }
            if (!isEmpty(bgImage)) {
                classes.push('tatsu-interactive-box-with-bg-image');
            }
            if (!isEmpty(style)) {
                classes.push('tatsu-interactive-box-' + style);
            }
            if ('flip' != style) {
                if (!isEmpty(customHeight)) {
                    classes.push('tatsu-interactive-box-custom-height');
                }
                if (overlay) {
                    classes.push('tatsu-interactive-box-overlay');
                }
            }
            if ('transform' === style) {
                if ('All:' === atts.get('svg_icon')) {
                    classes.push('tatsu-interactive-box-allow-overflow');
                }
            }
            if (!isEmpty(atts.get('css_classes'))) {
                classes.push(atts.get('css_classes'));
            }
            classes.push(generateVisibilityClasses(atts));
        }
        return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { onMouseEnter: this.handleHover,
                onMouseLeave: this.handleHover,
                className: classes.join(" "),
                style: jQuery.extend({}, cssObject.style['.tatsu-interactive-box'], cssObject.style['.tatsu-interactive-box-' + style], cssObject.style['.tatsu-interactive-box-custom-height'], cssObject.style['.tatsu-module'], cssObject.style['root'])
            }),
            ['flip' != style && overlay ? React.createElement('div', { className: 'tatsu-interactive-box-tatsu-overlay', style: cssObject.style['.tatsu-interactive-box-overlay::before'] }) : null, !isEmpty(url) ? React.createElement('a', { className: 'tatsu-interactive-box-link', href: url }) : null, !isEmpty(style) ? 'flip' == style ? this.getFlipHtml(atts) : 'stacked' == style ? this.getStackedHtml(atts) : this.getTransformHtml(atts) : null, 'transform' == style && !isEmpty(atts.get('hover_bg_color')) ? React.createElement('div', { style: cssObject.style['.tatsu-interactive-box-transform::after'], className: 'tatsu-interactive-box-transform-tatsu-hover-bg' }) : null]
        );
    }
});
module.exports = InteractiveBox;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(12), __webpack_require__(15)))

/***/ }),
/* 754 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var isEmpty = __webpack_require__(5);

var List = React.createClass({
	displayName: 'List',

render: function render() {

var list = this.props.module,
		    cssObject = this.props.cssObject.style,
		    gradientClass = this.props.cssObject.class,
		    atts = list.get('atts'),
		    icon = '',
		    content = '',
		    iconClass = 'tatsu-icon ',
		    circled = '',
		    key = list.get('id');

if (!isEmpty(atts)) {
			content = atts.get('content');
			icon = atts.get('icon');
			circled = atts.get('circled');
			if (!isEmpty(icon)) {
				iconClass = iconClass + icon;
				if (!isEmpty(circled)) {
					iconClass = iconClass + ' circled';
				}
			}
		}
		return React.createElement(
			'li',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-list-content " + generateVisibilityClasses(atts) + " " + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-list-content'], cssObject['.tatsu-list-bordered .tatsu-list-content'], cssObject['.' + key + '.tatsu-list-content'], cssObject['.' + key]) }),
			'icon' === this.props.listStyle ? React.createElement(
				'span',
				{ className: "tatsu-list-icon-wrap" + (!isEmpty(circled) ? " circled" : ''), style: jQuery.extend({}, cssObject['.tatsu-list-icon-wrap'], cssObject['.' + key + ' .tatsu-list-icon-wrap']) },
				React.createElement('i', { className: iconClass + ' ' + gradientClass['.' + key + ' .tatsu-icon'], style: jQuery.extend({}, cssObject['.tatsu-icon'], cssObject['.' + key + ' .tatsu-icon']) })
			) : React.createElement(
				'span',
				{ style: jQuery.extend({}, cssObject['.tatsu-list-content::before'], cssObject['.' + key + '.tatsu-list-content::before']), className: 'tatsu-list-item-numbered-before' },
				this.props.index + 1
			),
			React.createElement(
				'span',
				{ className: 'tatsu-list-inner' },
				'undefined' != typeof content ? React.createElement('div', { dangerouslySetInnerHTML: { __html: content } }) : null
			)
		);
	}

});
module.exports = List;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 755 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, generateVisibilityClasses, generateIdentifierId, jQuery) {

var List = __webpack_require__(754),
    isEmpty = __webpack_require__(5);
var Lists = React.createClass({
	displayName: 'Lists',

render: function render() {

var lists = this.props.module,

//targetDisplay = 'd',
		atts = lists.get('atts'),
		    classes = ['tatsu-list', 'tatsu-module'],
		    moduleOptions = this.props.moduleOptions,
		    cssObject = this.props.cssObject,
		    children = lists.get('inner') || Immutable.List();
		if (!isEmpty(atts)) {
			if (!isEmpty(atts.get('reverse_list'))) {
				classes.push('tatsu-reverse-list');
			}
			if (!isEmpty(atts.get('vertical_alignment'))) {
				classes.push('tatsu-list-vertical-align-' + atts.get('vertical_alignment'));
			}
			if (!isEmpty(atts.get('custom_border'))) {
				classes.push('tatsu-list-bordered');
			}
			if (!isEmpty(atts.get('circled'))) {
				classes.push('tatsu-lists-circled');
				if (!isEmpty(atts.get('timeline'))) {
					classes.push('tatsu-lists-timeline');
				}
			}
			if (!isEmpty(atts.get('style'))) {
				classes.push('tatsu-lists-' + atts.get('style'));
			}
			if (!isEmpty(atts.get('hide_in'))) {
				classes.push(generateVisibilityClasses(atts));
			}
			if (!isEmpty(atts.get('css_classes'))) {
				classes.push(atts.get('css_classes'));
			}
		}
		return React.createElement(
			'ul',
			_extends({}, generateIdentifierId(atts), { className: classes.join(' '), style: jQuery.extend({}, cssObject.style['.tatsu-list'], cssObject.style['root']) }),
			!isEmpty(atts.get('circled')) && !isEmpty(atts.get('timeline')) && React.createElement('span', { className: 'tatsu-lists-timeline-element', style: cssObject.style['.tatsu-lists-timeline-element'] }),
			children.map(function (list, index) {

return React.createElement(List, { index: index, listStyle: atts.get('style'), module: list, bordered: atts.get('custom_border'), moduleOptions: moduleOptions, cssObject: cssObject });
			}.bind(this))
		);
	}

});
module.exports = Lists;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 756 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var findDOMNode = __webpack_require__(7).findDOMNode,
    isEmpty = __webpack_require__(5);

var MultiLayerImage = React.createClass({
    displayName: 'MultiLayerImage',

//getStyle : function
    render: function render() {
        var multiLayerImage = this.props.module,
            moduleOptions = this.props.moduleOptions,
            atts = multiLayerImage.get('atts'),
            imageSrc,
            style,
            imgStyles,
            width,
            boxShadow,
            transformForOverflow = {},
            key = multiLayerImage.get('id'),
            imgClass;

var cssObject = this.props.cssObject.style,
            multiLayerImageWrapperStyle = cssObject['.' + key + '.tatsu-multi-layer-image'];
        imgStyles = cssObject['.' + key + ' img'];
        var cssObject = this.props.cssObject.style;

if (!isEmpty(atts)) {
            imageSrc = atts.get('image') || '';
            boxShadow = atts.get('box_shadow');
            width = atts.get('max_width');
            if (!isEmpty(atts.get('image_overflow')) && 'right' === atts.get('alignment')) {
                transformForOverflow = {
                    transform: 'translateX(-' + (parseInt(cssObject['.' + key + ' .tatsu-multi-layer-image-inner'].width) - 100) / parseInt(cssObject['.' + key + ' .tatsu-multi-layer-image-inner'].width) * 100 + '%)'
                };
            }
        }

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: "tatsu-multi-layer-image " + generateVisibilityClasses(atts) + " " + atts.get('css_classes'), style: jQuery.extend({}, multiLayerImageWrapperStyle, cssObject['.' + key]) }),
            React.createElement(
                'div',
                { className: 'tatsu-multi-layer-image-inner', style: jQuery.extend({}, cssObject['.' + key + ' .tatsu-multi-layer-image-inner'], cssObject['.' + key + '.tatsu-multi-layer-image .tatsu-multi-layer-image-inner'], transformForOverflow) },
                React.createElement('img', { className: imgClass, style: imgStyles, src: imageSrc })
            )
        );
    }

});

module.exports = MultiLayerImage;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 757 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, generateIdentifierId, generateVisibilityClasses, jQuery) {

var MultiLayerImage = __webpack_require__(756),
    isEmpty = __webpack_require__(5);

var MultiLayerImages = React.createClass({
    displayName: 'MultiLayerImages',

render: function render() {

module.exports = MultiLayerImages;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 758 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5);
var Notification = React.createClass({
	displayName: 'Notification',

getWrapperClass: function getWrapperClass(atts) {

var wrapperClass = 'tatsu-module tatsu-notification ',
		    scrollToAnimate = atts.get('scroll_to_animate');
		if (!isEmpty(scrollToAnimate)) {
			wrapperClass = wrapperClass + 'scrollToFade ';
		}
		return wrapperClass;
	},

render: function render() {

var notification = this.props.module,
		    atts = notification.get('atts'),
		    moduleOptions = this.props.moduleOptions,
		    wrapperClass = '',
		    content = '',
		    animationType = '',
		    cssObject = this.props.cssObject.style,
		    notificationStyle = cssObject['.tatsu-notification'];

var visibilityClass = generateVisibilityClasses(atts);

if (!isEmpty(atts)) {
			wrapperClass = this.getWrapperClass(atts), content = atts.get('content');
		}
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { style: jQuery.extend({}, notificationStyle, cssObject['root']), className: wrapperClass + visibilityClass + ' ' + atts.get('css_classes') }),
			React.createElement(
				'div',
				{ className: 'tatsu-notification-inner' },
				React.createElement(
					'span',
					{ className: 'close' },
					React.createElement('i', { className: 'tatsu-icon icon-icon_close' })
				),
				'undefined' != typeof content ? React.createElement('div', { dangerouslySetInnerHTML: { __html: content } }) : null
			)
		);
	}

});
module.exports = Notification;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 759 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5),
    ProcessCol = __webpack_require__(760);
var Process = React.createClass({
    displayName: 'Process',

render: function render() {
        var process = this.props.module,
            atts = process.get('atts'),
            titleFont = '',
            contentFont = '',
            dividerColor = '',
            cssObject = this.props.cssObject,
            children = process.get('inner'),
            visibilityClass = generateVisibilityClasses(atts),
            cssUtilClasses = ' ' + visibilityClass + ' ';

if (!isEmpty(atts)) {
            titleFont = atts.get('title_font') || '';
            dividerColor = atts.get('divider_color') || '';
            contentFont = atts.get('content_font') || '';
        }
        return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: "tatsu-process tatsu-module" + " " + cssUtilClasses + " " + atts.get('css_classes'), style: jQuery.extend({}, cssObject.style['.tatsu-module'], cssObject.style['root']) }),
            children.map(function (child) {
                return React.createElement(ProcessCol, { cssObject: cssObject, contentFont: contentFont, titleFont: titleFont, dividerColor: dividerColor, module: child, key: child.get('id') });
            })
        );
    }
});
module.exports = Process;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 760 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var getSvgIconPath = __webpack_require__(240),
    isEmpty = __webpack_require__(5),
    Vivus = __webpack_require__(200);
var ProcessCol = React.createClass({
    displayName: 'ProcessCol',

curEle: null,
    getInitialState: function getInitialState() {
        return {
            iconHover: false,
            titleHover: false
        };
    },
    handleTitleHover: function handleTitleHover() {
        var titleHover = this.state.titleHover;
        this.setState({
            titleHover: !titleHover
        });
    },
    handleIconHover: function handleIconHover() {
        var iconHover = this.state.iconHover;
        this.setState({
            iconHover: !iconHover
        });
    },
    triggerLineAnimate: function triggerLineAnimate() {
        var atts = this.props.module.get('atts'),
            svgIconPath = getSvgIconPath(atts.get('svg_icon')),
            lineAnimate = atts.get('line_animate');
        if (!isEmpty(svgIconPath) && null != this.curEle) {
            this.curEle.innerHTML = "";
            new Vivus(this.curEle, { duration: !isEmpty(lineAnimate) ? 85 : 1, start: 'manual', file: svgIconPath, onReady: function (e) {
                    e.play();
                }.bind(this) });
        }
    },
    componentDidMount: function componentDidMount() {
        if (null != this.curEle) {
            this.triggerLineAnimate();
        }
    },
    componentDidUpdate: function componentDidUpdate(prevProps) {
        var prevAtts = prevProps.module.get('atts'),
            curAtts = this.props.module.get('atts');
        if ('svg' == curAtts.get('icon_type')) {
            if ('icon' == prevAtts.get('icon_type') && 'svg' == curAtts.get('icon_type')) {
                this.triggerLineAnimate();
            } else if ('svg' == prevAtts.get('icon_type') && 'svg' == curAtts.get('icon_type')) {
                if (prevAtts.get('svg_icon') != curAtts.get('svg_icon')) {
                    this.triggerLineAnimate();
                } else if ('1' != prevAtts.get('line_animate') && '1' == curAtts.get('line_animate')) {
                    this.triggerLineAnimate();
                }
            }
        } else if (null != this.curEle) {
            this.curEle = null;
        }
    },
    render: function render() {
        var iconHover = this.state.iconHover,
            titleHover = this.state.titleHover,
            processCol = this.props.module,
            atts = processCol.get('atts'),
            id = processCol.get('id'),
            titleFont = this.props.titleFont,
            contentFont = this.props.contentFont,
            cssObject = this.props.cssObject,
            iconType = '',
            icon = '',
            sepTop = '',
            title = '',
            content = '',
            classes = ['tatsu-process-col'],
            visibilityClass = generateVisibilityClasses(atts);
        if (!isEmpty(atts)) {
            iconType = atts.get('icon_type') || 'icon';
            if ('icon' == iconType) {
                icon = atts.get('icon') || '';
            } else if (null != tatsuSvgs) {
                classes.push('tatsu-process-icon-type-svg');
            }
            sepTop = !isNaN(parseInt(cssObject.style['.tatsu-process-sep'].top)) ? parseInt(cssObject.style['.tatsu-process-sep'].top) / 2 : 11;
            sepTop = sepTop + 'px';
            title = atts.get('title') || '';
            content = atts.get('content') || '';
        }

classes.push(visibilityClass, atts.get('css_classes'), 'be-pb-observer-' + id);
        return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: classes.join(' '), style: cssObject.style['.' + id] }),
            React.createElement(
                'div',
                { className: 'tatsu-process-header' },
                React.createElement(
                    'div',
                    { className: 'tatsu-process-icon', style: cssObject.style['.tatsu-process-icon'] },
                    'icon' == iconType ? React.createElement('i', { onMouseEnter: this.handleIconHover, onMouseLeave: this.handleIconHover, className: "tatsu-icon " + icon, style: iconHover ? jQuery.extend({}, cssObject.style['.tatsu-process-icon i'], cssObject.style['.tatsu-process-icon i:hover']) : cssObject.style['.tatsu-process-icon i'] }) : React.createElement('div', { onMouseEnter: this.handleIconHover, onMouseLeave: this.handleIconHover,
                        ref: function (curEle) {
                            this.curEle = curEle;
                        }.bind(this), style: jQuery.extend({}, iconHover ? jQuery.extend({}, cssObject.style['.tatsu-process-icon svg'], cssObject.style['.tatsu-process-icon svg:hover']) : cssObject.style['.tatsu-process-icon svg'], { margin: '0 auto' }), dangerouslySetInnerHTML: { __html: '' } })
                ),
                React.createElement(
                    'div',
                    { onMouseEnter: this.handleTitleHover, onMouseLeave: this.handleTitleHover, className: "tatsu-process-title " + titleFont, style: titleHover ? jQuery.extend({}, cssObject.style['.tatsu-process-title'], cssObject.style['.tatsu-process-title:hover']) : cssObject.style['.tatsu-process-title'] },
                    title
                )
            ),
            React.createElement('div', { className: "tatsu-process-content " + contentFont, style: cssObject.style['.tatsu-process-content'], dangerouslySetInnerHTML: { __html: content } }),
            React.createElement('div', { className: 'tatsu-process-sep', style: jQuery.extend({}, cssObject.style['.tatsu-process-sep'], { top: sepTop }) })
        );
    }
});
module.exports = ProcessCol;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 761 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, jQuery) {

var parseValue = __webpack_require__(42),
    Inlineinner = __webpack_require__(382),
    isEmpty = __webpack_require__(5),
    getConcatenatedCSS = __webpack_require__(67);
var SimpleText = React.createClass({
    displayName: 'SimpleText',

shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {

var currentAtts = this.props.atts,
            newAtts = nextProps.atts;
        return !Immutable.is(currentAtts, newAtts);
    },

render: function render() {

var simpleText = this.props.module,
            innerStyle = {},
            atts = simpleText.get('atts'),
            margin = atts.get('margin') || '0',
            wrapAlignment = atts.get('wrap_alignment'),
            TitleTag = atts.get('tag_to_use'),
            content = atts.get('content');

if (!isEmpty(wrapAlignment)) {
            switch (wrapAlignment) {
                case 'left':
                    innerStyle.marginLeft = '0';
                    break;
                case 'right':
                    innerStyle.marginLeft = 'auto';
                    innerStyle.marginRight = '0';
                    break;
                case 'center':
                    innerStyle.marginRight = 'auto';
                    innerStyle.marginLeft = 'auto';
                    break;
                default:
                    break;
            }
        }

var cssObject = this.props.cssObject.style,
            simpleTextStyle = cssObject['.simple-text'],
            simpleTextInnerStyle = cssObject['.simple-text-inner'],
            simpleTagTextStyle = cssObject['.simple-text-tag'],
            gradientColorStyle = cssObject['.background-switcher-class'];

simpleTagTextStyle.display = 'inline-block';
        simpleTagTextStyle = jQuery.extend({}, gradientColorStyle, simpleTagTextStyle);

var gradientClass = this.props.cssObject.class,
            simpleTagTextClass = gradientClass['.background-switcher-class'];

return React.createElement(
            'div',
            { className: "tatsu-module simple-text " + gradientClass['.simple-text'], style: simpleTextStyle },
            React.createElement(
                'div',
                { className: "simple-text-inner ", style: jQuery.extend({}, innerStyle, simpleTextInnerStyle) },
                React.createElement(TitleTag, { className: "simple-text-tag " + simpleTagTextClass, style: simpleTagTextStyle, dangerouslySetInnerHTML: { __html: content } })
            )
        );
    }

});
module.exports = SimpleText;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(4)))

/***/ }),
/* 762 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var parseValue = __webpack_require__(42),
    mapChecker = __webpack_require__(16).mapChecker,
    parseCustomField = __webpack_require__(38),
    findDOMNode = __webpack_require__(7).findDOMNode,
    jsTrigger = __webpack_require__(126),
    isEmpty = __webpack_require__(5);

var SingleImage = React.createClass({
	displayName: 'SingleImage',

triggerJs: false,

componentDidMount: function componentDidMount() {

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {

var currentLightboxValue = this.props.module.getIn(['atts', 'lightbox']),
		    newLightboxValue = nextProps.module.getIn(['atts', 'lightbox']);
		if (isEmpty(currentLightboxValue) && !isEmpty(newLightboxValue)) {
			this.triggerJs = true;
		}
	},

getStyle: function getStyle(atts) {

componentDidUpdate: function componentDidUpdate() {

_getBorder: function _getBorder(atts) {

render: function render() {

visibilityClass = generateVisibilityClasses(atts);

if (rebel === '1' && alignment === 'right') {
			transformForRebel = { transform: 'translateX(-' + (parseInt(singleImageInner['width']) - 100) / parseInt(singleImageInner['width']) * 100 + '%)' };
		}
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-single-image tatsu-module align-" + alignment + ('full' == size && '1' == rebel ? " tatsu-image-overflow" : "") + boxShadow + visibilityClass + ' ' + atts.get('css_classes'), style: jQuery.extend({}, singleImageWrapperStyle, cssObject['root']) }),
			React.createElement(
				'div',
				{ className: "tatsu-single-image-inner " + gradientClass['.tatsu-single-image-inner'], style: jQuery.extend({}, singleImageInner, transformForRebel) },
				!isEmpty(lightbox) ? React.createElement(
					'a',
					{ href: imageVaryingSizeSrc || imageSrc, className: 'mfp-image' },
					React.createElement('img', { className: imgClass, style: singleImageStyle, src: imageVaryingSizeSrc || imageSrc })
				) : 'string' == typeof link && '' != link ? React.createElement(
					'a',
					{ href: link },
					React.createElement('img', { className: imgClass, style: singleImageStyle, src: imageVaryingSizeSrc || imageSrc })
				) : React.createElement('img', { className: imgClass, style: singleImageStyle, src: imageVaryingSizeSrc || imageSrc })
			)
		);
	}

});
SingleImage.propTypes = {

module: mapChecker,
	moduleOptions: mapChecker

};
module.exports = SingleImage;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 763 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5),
    parseValue = __webpack_require__(42);
var Skill = React.createClass({
    displayName: 'Skill',

render: function render() {

var skill = this.props.module,
            id = '.' + skill.get('id'),
            moduleOptions = this.props.moduleOptions,
            atts = skill.get('atts'),
            cssObject = this.props.cssObject.style,
            direction = this.props.direction,
            title = '',
            value = '',
            cssObject = this.props.cssObject,
            gradientClass = this.props.gradientClass,
            visibilityClass = generateVisibilityClasses(atts),
            cssUtilClasses = ' ' + visibilityClass + ' be-pb-observer-' + skill.get('id');

if (!isEmpty(atts)) {

title = atts.get('title');
            value = parseValue(skill.get('name'), 'value', atts.get('value'), moduleOptions);
            if ('string' === typeof value && '' != value.replace(/\D+/, '') && !isNaN(value.replace(/\D+/, ''))) {
                //value = value;
            } else {
                value = '100%';
            }
        }
        return 'horizontal' === direction ? React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: "skill-wrap" + " " + cssUtilClasses + " " + atts.get('css_classes') + " ", style: cssObject[id] }),
            React.createElement(
                'h6',
                { className: "skill_name " + (!isEmpty(cssObject[id + '.skill-wrap .skill_name']) ? gradientClass[id + '.skill-wrap .skill_name'] : !isEmpty(cssObject['.skill_name']) ? gradientClass['.skill_name'] : ''), style: jQuery.extend({}, cssObject['.skill_name'], cssObject[id + '.skill-wrap .skill_name']) },
                title
            ),
            React.createElement(
                'div',
                { className: 'skill-bar', style: jQuery.extend({}, cssObject['.skill-bar'], cssObject[id + '.skill-wrap .skill-bar']) },
                React.createElement('span', { className: 'be-skill expand alt-bg alt-bg-text-color', 'data-skill-value': value, style: jQuery.extend({}, cssObject['.be-skill'], cssObject[id + '.skill-wrap .be-skill']) })
            )
        ) : React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: "skill-wrap" + " " + cssUtilClasses + " " + atts.get('css_classes') + " ", style: cssObject[id] }),
            React.createElement(
                'div',
                { className: 'skill-bar', style: jQuery.extend({}, cssObject['.skill-bar'], cssObject[id + '.skill-wrap .skill-bar']) },
                React.createElement('span', { className: 'be-skill expand alt-bg alt-bg-text-color', 'data-skill-value': value, style: jQuery.extend({}, cssObject['.be-skill'], cssObject[id + '.skill-wrap .be-skill']) })
            ),
            React.createElement(
                'h6',
                { className: "skill_name " + (!isEmpty(cssObject[id + '.skill-wrap .skill_name']) ? gradientClass[id + '.skill-wrap .skill_name'] : !isEmpty(cssObject['.skill_name']) ? gradientClass['.skill_name'] : ''), style: jQuery.extend({}, cssObject['.skill_name'], cssObject[id + '.skill-wrap .skill_name']) },
                title
            )
        );
    }

});
module.exports = Skill;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 764 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5),
    Skill = __webpack_require__(763);
var Skills = React.createClass({
    displayName: 'Skills',

render: function render() {

var skills = this.props.module,
            moduleOptions = this.props.moduleOptions,
            atts = skills.get('atts'),
            cssObject = this.props.cssObject,
            children = skills.get('inner') || Immutable.List(),
            direction = 'horizontal',
            styleClass = '',
            cssObject = this.props.cssObject.style,
            gradientClass = this.props.cssObject.class,
            visibilityClass = generateVisibilityClasses(atts),
            cssUtilClasses = ' ' + visibilityClass;

if (!isEmpty(atts)) {
            direction = atts.get('direction');
            if (isEmpty(direction)) {
                direction = 'horizontal';
            }
            if (!isEmpty(atts.get('style'))) {
                styleClass = ' tatsu-skill-' + atts.get('style');
            }
        }
        return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: "tatsu-module skill_container skill-" + direction + styleClass + " " + cssUtilClasses + " " + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-module'], cssObject['root']) }),
            React.createElement(
                'div',
                { className: 'skill clearfix' },
                children.map(function (skill) {

return React.createElement(Skill, { key: skill.get('id'), module: skill, moduleOptions: moduleOptions, direction: direction, cssObject: cssObject, gradientClass: gradientClass });
                })
            )
        );
    }

});
module.exports = Skills;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 765 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, jQuery, generateIdentifierId) {

var isEmpty = __webpack_require__(5);

var SpecialHeading = React.createClass({
    displayName: 'SpecialHeading',

getInitialState: function getInitialState() {
        return { hovered: false };
    },

hoverHandler: function hoverHandler() {
        this.setState({
            hovered: !this.state.hovered
        });
    },

render: function render() {

var atts = this.props.atts,
            title = '',
            expandOnHover = false,
            borderStyle = 'style1',
            titleStyle,
            titleHoverStyle,
            cssObject = this.props.cssObject.style,
            visibilityClass = generateVisibilityClasses(atts);

if (!isEmpty(atts)) {
            title = atts.get('title_content') || '';
            borderStyle = atts.get('border_style');
            expandOnHover = atts.get('expand_border');
        }

titleStyle = cssObject['.tatsu-special-heading-wrap .tatsu-title'];
        titleHoverStyle = jQuery.extend({}, titleStyle, cssObject['.tatsu-special-heading-wrap .special-heading-inner-wrap:hover .tatsu-title']);

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: "tatsu-module tatsu-special-heading-wrap " + visibilityClass + " " + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-special-heading-wrap'], cssObject['root']) }),
            React.createElement(
                'div',
                { className: "special-heading-inner-wrap" + (!isEmpty(borderStyle) ? " tatsu-border-" + borderStyle : "") + (!isEmpty(expandOnHover) ? " tatsu-expand" : ""), onMouseEnter: this.hoverHandler.bind(this), onMouseLeave: this.hoverHandler.bind(this) },
                React.createElement('div', { className: 'tatsu-border', style: cssObject['.tatsu-special-heading-wrap .tatsu-border'] }),
                React.createElement(
                    'h6',
                    { className: 'tatsu-title', style: this.state.hovered ? titleHoverStyle : titleStyle },
                    "string" === typeof title ? title : ""
                )
            )
        );
    }

});
module.exports = SpecialHeading;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(4), __webpack_require__(15)))

/***/ }),
/* 766 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5);

var StarRating = React.createClass({
    displayName: 'StarRating',

componentDidUpdate: function componentDidUpdate(prevProps) {
        if ('none' != prevProps.atts.get('alignment') && 'none' == this.props.atts.get('alignment')) {
            this.curEle.parentElement.style.display = 'inline-block';
        } else if ('none' == prevProps.atts.get('alignment') && 'none' != this.props.atts.get('alignment')) {
            this.curEle.parentElement.style.display = 'block';
        }
    },
    componentDidMount: function componentDidMount() {
        if ('none' == this.props.atts.get('alignment')) {
            this.curEle.parentElement.style.display = 'inline-block';
        }
    },
    render: function render() {
        var moduleStyles = this.props.cssObject.style,
            moduleClasses = this.props.cssObject.class,
            atts = this.props.module.get('atts'),
            alingment = atts.get('alignment');
        var visibilityClass = generateVisibilityClasses(atts);

/***/ }),
/* 767 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateVisibilityClasses, generateIdentifierId) {

var getSvgIconPath = __webpack_require__(240),
    isEmpty = __webpack_require__(5),
    Vivus = __webpack_require__(200),
    findDOMNode = ReactDOM.findDOMNode;

var SvgIcon = React.createClass({
    displayName: 'SvgIcon',

triggerLineAnimte: function triggerLineAnimte() {
        var atts = this.props.module.get('atts'),
            svgPath = isEmpty(atts.get('custom_icon')) ? getSvgIconPath(atts.get('svg_icon')) : atts.get('svg_url'),
            svgParent = this.svgParent,
            animTimingFunc = atts.get('svg_animation_type') || 'EASE',
            pathTimingFunc = atts.get('path_animation_type') || 'EASE',
            duration = atts.get('animation_duration') || 100,
            lineAnimate = atts.get('line_animate');
        if (!isEmpty(svgPath) && null != svgParent) {
            svgParent.innerHTML = "";
            new Vivus(svgParent, {
                duration: isEmpty(lineAnimate) ? 1 : duration,
                file: svgPath, animTimingFunction: Vivus[animTimingFunc],
                pathTimingFunction: Vivus[pathTimingFunc],
                start: 'autostart',
                onReady: function onReady(e) {
                    var svgEle = e.el;
                    if (null != svgEle && 1 < svgEle.parentElement.children.length) {
                        svgEle.parentElement.removeChild(svgEle);
                    } else {
                        svgEle.style.stroke = "inherit";
                        if (!isEmpty(lineAnimate)) {
                            svgParent.classList.add('tatsu-line-animate-ready');
                        }
                        e.play();
                    }
                }
            });
        }
    },
    componentDidUpdate: function componentDidUpdate(prevProps) {
        var curAtts = this.props.module.get('atts'),
            prevAtts = prevProps.module.get('atts'),
            curPath = isEmpty(curAtts.get('custom_icon')) ? curAtts.get('svg_icon') : curAtts.get('svg_url'),
            prevPath = isEmpty(prevAtts.get('custom_icon')) ? prevAtts.get('svg_icon') : prevAtts.get('svg_url'),
            curAlignment = curAtts.get('alignment'),
            prevAlignment = prevAtts.get('alignment'),
            curLineAnimate = curAtts.get('line_animate'),
            prevLineAnimate = prevAtts.get('line_animate');

//alignment
        if ('none' != prevAlignment && 'none' == curAlignment) {
            findDOMNode(this).parentElement.style.display = 'inline-block';
        } else if ('none' == prevAlignment && 'none' != curAlignment) {
            findDOMNode(this).parentElement.style.display = 'block';
        }

//line animate
        if (isEmpty(prevLineAnimate) && !isEmpty(curLineAnimate)) {
            this.triggerLineAnimte();
        } else if (!isEmpty(prevLineAnimate) && !isEmpty(curLineAnimate)) {
            if (curAtts.get('path_animation_type') != prevAtts.get('path_animation_type')) {
                this.triggerLineAnimte();
            } else if (curAtts.get('svg_animation_type') != prevAtts.get('svg_animation_type')) {
                this.triggerLineAnimte();
            } else if (curAtts.get('animation_duration') != prevAtts.get('animation_duration')) {
                this.triggerLineAnimte();
            }
        }

//svg path change
        if ('' != prevPath && '' == curPath) {
            this.svgParent.innerHTML = '';
        } else if (prevPath !== curPath) {
            this.triggerLineAnimte();
        }

//animation duration - Had to do it manually because of key override
        if (!isEmpty(curAtts.get('animate')) && 'none' !== curAtts.get('animation_type') && (prevAtts.get('animation_type') !== curAtts.get('animation_type') || prevAtts.get('animation_delay') !== curAtts.get('animation_delay') || prevAtts.get('module_animation_duration') !== curAtts.get('module_animation_duration'))) {
            jQuery(findDOMNode(this).parentElement).removeClass('animated flipInX flipInY fadeIn fadeInDown fadeInLeft fadeInRight fadeInUp slideInDown slideInLeft slideInRight rollIn rollOut bounce bounceIn bounceInUp bounceInDown bounceInLeft bounceInRight fadeInUpBig fadeInDownBig fadeInLeftBig fadeInRightBig flash flip lightSpeedIn pulse rotateIn rotateInUpLeft rotateInDownLeft rotateInUpRight rotateInDownRight shake swing tada wiggle wobble infiniteJump zoomIn none already-visible end-animation');
            var triggerInformation = {
                type: 'csstrigger',
                animationDetails: {
                    id: this.props.module.get('id'),
                    animation: this.props.module.getIn(['atts', 'animation_type']),
                    animationDelay: this.props.module.getIn(['atts', 'animation_delay']),
                    animationDuration: this.props.module.getIn(['atts', 'module_animation_duration'])
                }
            },
                jsonData = JSON.stringify(triggerInformation);
            document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
        }
    },
    componentDidMount: function componentDidMount() {
        var curIcon = isEmpty(this.props.module.getIn(['atts', 'custom_icon'])) ? this.props.module.getIn(['atts', 'svg_icon']) : this.props.module.getIn(['atts', 'svg_url']);
        if ('' != curIcon) {
            this.triggerLineAnimte();
        }
        if ('none' == this.props.module.getIn(['atts', 'alignment'])) {
            findDOMNode(this).parentElement.style.display = 'inline-block';
        }
        //animation duration - Had to do it manually because of key override
        if (!isEmpty(this.props.module.getIn(['atts', 'animate'])) && 'none' !== this.props.module.getIn(['atts', 'animation_type'])) {
            var triggerInformation = {
                type: 'csstrigger',
                animationDetails: {
                    id: this.props.module.get('id'),
                    animation: this.props.module.getIn(['atts', 'animation_type']),
                    animationDelay: this.props.module.getIn(['atts', 'animation_delay']),
                    animationDuration: this.props.module.getIn(['atts', 'module_animation_duration'])
                }
            },
                jsonData = JSON.stringify(triggerInformation);
            document.getElementById('tatsu-preview').contentWindow.postMessage(jsonData, '*');
        }
    },
    render: function render() {
        var svgIcon = this.props.module,
            atts = svgIcon.get('atts'),
            size,
            cssObject = this.props.cssObject,
            style = '',
            iconTypeClass = '',
            iconStyleClass = '',
            alignment,
            cssAnimationDuration = '',
            visibility_classes = " " + generateVisibilityClasses(atts) + " ",
            lineAnimate;

size = atts.get('size');
        style = atts.get('style');
        if (isEmpty(size)) {
            size = 'small';
        }
        alignment = atts.get('alignment') || '';
        iconTypeClass = !isEmpty(atts.get('custom_icon')) ? ' tatsu-svg-icon-custom' : ' tatsu-svg-icon-default';
        iconStyleClass = !isEmpty(style) ? ' tatsu-svg-icon-' + style : '';
        lineAnimate = atts.get('line_animate');
        if (isEmpty(lineAnimate)) {
            lineAnimate = '';
        } else {
            lineAnimate = ' tatsu-line-animate';
        }

if (!isEmpty(atts.get('animation_duration'))) {
            cssAnimationDuration = atts.get('animation_duration');
        }
        // handle operation property
        if (cssObject.style.hasOwnProperty('.tatsu-svg-icon-inner') && cssObject.style['.tatsu-svg-icon-inner'].hasOwnProperty('padding')) {
            cssObject.style['.tatsu-svg-icon-inner'].padding = parseInt(cssObject.style['.tatsu-svg-icon-inner'].padding) / 2 + 'px';
        }

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), {
                className: 'tatsu-svg-icon tatsu-module align-' + alignment + ' ' + size + lineAnimate + iconTypeClass + iconStyleClass + visibility_classes + atts.get('css_classes'),
                style: jQuery.extend({}, cssObject.style['.tatsu-module'], cssObject.style['root']),

'data-line-animation-duration': !isEmpty(cssAnimationDuration) ? cssAnimationDuration : null
            }),
            React.createElement(
                'div',
                { className: 'tatsu-svg-icon-inner', style: cssObject.style['.tatsu-svg-icon-inner'] },
                React.createElement('div', { ref: function (svgParent) {
                        this.svgParent = svgParent;
                    }.bind(this), style: jQuery.extend({}, cssObject.style['svg'], { display: 'inline-block' }), className: 'tatsu-svg-holder', dangerouslySetInnerHTML: { __html: '' } })
            )
        );
    }

});

module.exports = SvgIcon;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(12), __webpack_require__(15)))

/***/ }),
/* 768 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5);

var TabHeader = React.createClass({
    displayName: 'TabHeader',

render: function render() {
        var tabHeader = this.props.module,
            tabsCount = this.props.tabsCount,
            cssObject = this.props.cssObject.style,
            rand = tabHeader.get('id'),
            atts = tabHeader.get('atts'),
            icon,
            title;

if (!isEmpty(atts)) {
            icon = atts.get('icon');
            if (!isEmpty(icon)) {
                icon = 'tab-icon ' + icon;
            } else {
                icon = '';
            }
            title = atts.get('title');
            if (isEmpty(title)) {
                title = '';
            }
        }
        return React.createElement(
            'li',
            { style: cssObject[".ui-state-default"] },
            React.createElement(
                'a',
                { className: 'h6', href: '#fragment-' + tabsCount + '-' + rand },
                !isEmpty(icon) && React.createElement('i', { className: icon }),
                title
            )
        );
    }
});

var TabPane = React.createClass({
    displayName: 'TabPane',

render: function render() {
        var tabPane = this.props.module,
            tabsCount = this.props.tabsCount,
            atts = tabPane.get('atts'),
            id,
            content;
        id = tabPane.get('id');
        if (isEmpty(id)) {
            id = '';
        }
        content = atts.get('content');
        if (isEmpty(content)) {
            content = '';
        }
        return React.createElement('div', { id: 'fragment-' + tabsCount + '-' + id, dangerouslySetInnerHTML: { __html: content }, className: 'clearfix be-tab-content' });
    }
});

var Tabs = React.createClass({
    displayName: 'Tabs',

render: function render() {
        var tabsCount = 0,
            tabs = this.props.module,
            moduleOptions = this.props.moduleOptions,
            cssObject = this.props.cssObject,
            atts = tabs.get('atts'),
            children = tabs.get('inner') || Immutable.List(),
            tabsCount = children.size,
            key = atts.get('id'),
            style = atts.get('style'),
            margin,
            visibilityClass = generateVisibilityClasses(atts);

margin = cssObject.style['.tatsu-module'];

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: 'tatsu-tabs tatsu-module tatsu-tabs-' + style + ' ' + visibilityClass + ' ' + atts.get('css_classes'), style: jQuery.extend({}, margin, cssObject.style['root']) }),
            React.createElement(
                'div',
                { className: 'tatsu-tabs-inner', 'data-active-colors': JSON.stringify(cssObject.style[".ui-state-default.ui-tabs-active"]), 'data-normal-colors': JSON.stringify(cssObject.style[".ui-state-default"]) },
                React.createElement(
                    'ul',
                    { className: 'clearfix be-tab-header', style: cssObject.style['.ui-tabs .ui-tabs-nav'] },
                    children.map(function (tab) {

return React.createElement(TabHeader, { key: tab.get('id'), tabsCount: tabsCount, module: tab, moduleOptions: moduleOptions, cssObject: cssObject });
                    })
                ),
                children.map(function (tab) {
                    return React.createElement(TabPane, { key: tab.get('id'), tabsCount: tabsCount, module: tab, moduleOptions: moduleOptions });
                })
            )
        );
    }
});

module.exports = Tabs;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 769 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateVisibilityClasses, generateIdentifierId) {

var isEmpty = __webpack_require__(5),
    parseCustomField = __webpack_require__(38);

var Team = React.createClass({
    displayName: 'Team',

getInitialState: function getInitialState() {
        return {
            hover: false,
            nameHover: false,
            designationHover: false,
            iconHover: false,
            iconHoverIndex: -1
        };
    },

hoverHandler: function hoverHandler() {
        var currentState = this.state.hover;
        this.setState({
            hover: !currentState
        });
    },

nameHoverHandler: function nameHoverHandler() {
        var currentState = this.state.nameHover;
        this.setState({
            nameHover: !currentState
        });
    },

designationHoverHandler: function designationHoverHandler() {
        var currentState = this.state.designationHover;
        this.setState({
            designationHover: !currentState
        });
    },

iconHoverHandler: function iconHoverHandler(index, e) {
        var currentState = this.state.iconHover;
        if (!currentState) {
            this.setState({
                iconHover: !currentState,
                iconHoverIndex: index
            });
        } else {
            this.setState({
                iconHover: !currentState,
                iconHoverIndex: -1
            });
        }
    },

getIcon: function getIcon(atts, cssObject) {
        var hasIcon = !isEmpty(atts.get('facebook')) || !isEmpty(atts.get('twitter')) || !isEmpty(atts.get('google_plus')) || !isEmpty(atts.get('instagram')) || !isEmpty(atts.get('linkedin')) || !isEmpty(atts.get('email')),
            iconsArray = [{
            url: parseCustomField(atts.get('facebook')),
            icon: 'tatsu-icon-facebook'
        }, {
            url: parseCustomField(atts.get('twitter')),
            icon: 'tatsu-icon-twitter'
        }, {
            url: parseCustomField(atts.get('google_plus')),
            icon: 'tatsu-icon-gplus'
        }, {
            url: parseCustomField(atts.get('instagram')),
            icon: 'tatsu-icon-instagram'
        }, {
            url: parseCustomField(atts.get('linkedin')),
            icon: 'tatsu-icon-linkedin'
        }, {
            url: parseCustomField(atts.get('email')),
            icon: 'tatsu-icon-mail2'
        }];

return hasIcon ? React.createElement(
            'div',
            { className: 'tatsu-team-member-social-details' },
            iconsArray.map(function (iconData, index) {
                if (!isEmpty(iconData.url)) {
                    return React.createElement(
                        'a',
                        { key: index, className: 'tatsu-team-member-social-icon', href: iconData.url, onMouseEnter: this.iconHoverHandler.bind(null, index), onMouseLeave: this.iconHoverHandler },
                        React.createElement('i', { style: this.state.iconHover && this.state.iconHoverIndex === index ? jQuery.extend({}, cssObject['.tatsu-team-member-social-icon i'], cssObject['.tatsu-team-member-social-icon:hover i']) : cssObject['.tatsu-team-member-social-icon i'], className: iconData.icon })
                    );
                }
                return null;
            }.bind(this))
        ) : null;
    },

render: function render() {

var team = this.props.module,
            atts = team.get('atts'),
            name = '',
            classes = ['tatsu-team', 'tatsu-module'],
            designation = '',
            nameFont = '',
            designationFont = '',
            hasIcon = !isEmpty(atts.get('facebook')) || !isEmpty(atts.get('twitter')) || !isEmpty(atts.get('google_plus')) || !isEmpty(atts.get('instagram')) || !isEmpty(atts.get('linkedin')) || !isEmpty(atts.get('email')),
            cssObject = this.props.cssObject.style,
            overlayStyle = cssObject['.tatsu-team-overlay'],
            nameStyle = this.state.nameHover ? jQuery.extend({}, cssObject['.tatsu-team-member-name'], cssObject['.tatsu-team-member-name:hover']) : cssObject['.tatsu-team-member-name'],
            designationStyle = this.state.designationHover ? jQuery.extend({}, cssObject['.tatsu-team-member-designation'], cssObject['.tatsu-team-member-designation:hover']) : cssObject['.tatsu-team-member-designation'],
            image = '';

if (!isEmpty(atts)) {
            name = atts.get('title');
            if (!isEmpty(atts.get('style'))) {
                classes.push('tatsu-team-' + atts.get('style'));
            } else {
                classes.push('tatsu-team-style1');
            }
            if (!isEmpty(atts.get('css_classes'))) {
                classes.push(atts.get('css_classes'));
            }
            classes.push(generateVisibilityClasses(atts));
            if (!isEmpty(atts.get('title_alignment_static'))) {
                classes.push('tatsu-team-align-' + atts.get('title_alignment_static'));
            } else {
                classes.push('tatsu-team-align-center');
            }
            if (!isEmpty(atts.get('facebook')) || !isEmpty(atts.get('twitter')) || !isEmpty(atts.get('google_plus')) || !isEmpty(atts.get('instagram'))) {
                classes.push('tatsu-team-has-icons');
            }
            nameFont = !isEmpty(atts.get('name_font')) ? atts.get('name_font') : '';
            designation = atts.get('designation');
            designationFont = !isEmpty(atts.get('designation_font')) ? atts.get('designation_font') : '';
            image = !isEmpty(atts.get('image')) ? atts.get('image') : '';
        }

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: classes.join(' '), onMouseEnter: this.hoverHandler, onMouseLeave: this.hoverHandler, style: jQuery.extend({}, cssObject['.tatsu-module'], cssObject['root']) }),
            !isEmpty(image) ? React.createElement(
                'div',
                { className: 'tatsu-team-image' },
                React.createElement('img', { src: image })
            ) : null,
            ('' != name || '' != designation || hasIcon) && React.createElement(
                'div',
                { className: 'tatsu-team-overlay', style: overlayStyle },
                React.createElement(
                    'div',
                    { className: 'tatsu-team-member-details' },
                    ('' != name || '' != designation) && React.createElement(
                        'div',
                        { className: 'tatsu-team-member-name-designation' },
                        '' != name && React.createElement(
                            'div',
                            { className: "tatsu-team-member-name " + nameFont, onMouseEnter: this.nameHoverHandler, onMouseLeave: this.nameHoverHandler, style: nameStyle },
                            parseCustomField(name)
                        ),
                        '' != designation && React.createElement(
                            'div',
                            { className: "tatsu-team-member-designation " + designationFont, onMouseEnter: this.designationHoverHandler, onMouseLeave: this.designationHoverHandler, style: designationStyle },
                            parseCustomField(designation)
                        )
                    ),
                    this.getIcon(atts, cssObject)
                )
            )
        );
    }
});

module.exports = Team;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(12), __webpack_require__(15)))

/***/ }),
/* 770 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId) {

var isEmpty = __webpack_require__(5);

var Testimonial = React.createClass({
	displayName: 'Testimonial',

getAuthor: function getAuthor(author, authorStyle) {
		if ('undefined' != typeof author) {
			return React.createElement(
				'div',
				{ className: 'name-container' },
				React.createElement(
					'span',
					{ className: 'name', style: authorStyle },
					author
				)
			);
		} else {
			return null;
		}
	},
	getAuthorRole: function getAuthorRole(authorRole, authorRoleStyle) {
		if ('undefined' != typeof authorRole) {
			return React.createElement(
				'div',
				{ className: 'designation-container', style: authorRoleStyle },
				React.createElement(
					'span',
					{ className: 'designation' },
					authorRole
				)
			);
		} else {
			return null;
		}
	},
	getContent: function getContent() {
		var content = this.props.module.getIn(['atts', 'content']),
		    authorImage,
		    cssObject = this.props.cssObject.style;
		if ('style2' == this.props.testimonialStyle) {
			return React.createElement('div', { style: cssObject['.tatsu-testimonial-content'], className: 'tatsu-testimonial-content', dangerouslySetInnerHTML: { __html: content } });
		} else {
			authorImage = this.props.module.getIn(['atts', 'author_image']);
			return React.createElement(
				'div',
				{ className: 'tatsu-testimonial-content-image-wrap' },
				null != authorImage ? React.createElement(
					'div',
					{ className: 'tatsu-testimonial-author-image' },
					React.createElement('img', { style: cssObject['.tatsu-testimonial-author-image img'], src: authorImage })
				) : null,
				React.createElement('div', { style: cssObject['.tatsu-testimonial-content'], className: 'tatsu-testimonial-content', dangerouslySetInnerHTML: { __html: content } })
			);
		}
	},
	getAuthorNameAndRole: function getAuthorNameAndRole() {
		var authorName = this.props.module.getIn(['atts', 'author']),
		    authorFont = this.props.authorFont,
		    authorRoleFont = this.props.authorRoleFont,
		    cssObject = this.props.cssObject.style,
		    authorClass = ['tatsu-testimonial-author'],
		    authorRoleClass = ['tatsu-testimonial-author-role'],
		    authorRole = this.props.module.getIn(['atts', 'author_role']);
		if (!isEmpty(authorFont)) {
			authorClass.push(authorFont);
		}
		if (!isEmpty(authorRoleFont)) {
			authorRoleClass.push(authorRoleFont);
		}
		authorClass = authorClass.join(' ');
		authorRoleClass = authorRoleClass.join(' ');
		return 'style2' == this.props.testimonialStyle ? React.createElement(
			'div',
			{ className: 'tatsu-testimonial-author-wrap' },
			[null != authorName ? React.createElement(
				'h6',
				{ style: cssObject['.tatsu-testimonial-author'], className: authorClass },
				authorName
			) : null, null != authorRole ? React.createElement(
				'div',
				{ style: cssObject['.tatsu-testimonial-author-role'], className: authorRoleClass },
				authorRole
			) : null]
		) : React.createElement(
			'div',
			{ className: 'tatsu-testimonial-author-details-wrap' },
			[null != authorName ? React.createElement(
				'h6',
				{ style: cssObject['.tatsu-testimonial-author'], className: authorClass },
				authorName
			) : null, null != authorRole ? React.createElement(
				'div',
				{ style: cssObject['.tatsu-testimonial-author-role'], className: authorRoleClass },
				authorRole
			) : null]
		);
	},
	getAuthorDetails: function getAuthorDetails() {
		var cssObject = this.props.cssObject.style,
		    authorImage;
		if ('style2' == this.props.testimonialStyle) {
			authorImage = this.props.module.getIn(['atts', 'author_image']);
			return React.createElement(
				'div',
				{ className: 'tatsu-testimonial-author-details-wrap' },
				[null != authorImage ? React.createElement(
					'div',
					{ className: 'tatsu-testimonial-author-image' },
					React.createElement('img', { style: cssObject['.tatsu-testimonial-author-image img'], src: authorImage })
				) : null, this.getAuthorNameAndRole()]
			);
		} else {
			return this.getAuthorNameAndRole();
		}
	},
	render: function render() {

var id = this.props.module.get('id'),
		    atts = this.props.module.get('atts'),
		    cssObject = this.props.cssObject.style;

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-testimonial " + atts.get('css_classes'), style: cssObject['.' + id] }),
			[this.getContent(), this.getAuthorDetails()]
		);
	}
});

module.exports = Testimonial;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15)))

/***/ }),
/* 771 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, Immutable, generateVisibilityClasses, generateIdentifierId, jQuery) {

var Testimonial = __webpack_require__(770),
    isEmpty = __webpack_require__(5),
    PrevArrow = __webpack_require__(157).PrevArrow,
    NextArrow = __webpack_require__(157).NextArrow,
    Slider = ReactSlick.default;
var Testimonials = React.createClass({
	displayName: 'Testimonials',

autoPlayTimer: null,
	clearCustomAutoplay: function clearCustomAutoplay() {
		if (null != this.autoPlayTimer) {
			clearInterval(this.autoPlayTimer);
			this.autoPlayTimer = null;
		}
	},
	customAutoplay: function customAutoplay() {
		var testimonial = this.props.module,
		    autoPlaySpeed = parseInt(testimonial.getIn(['atts', 'slide_show_speed'])) || 1000;
		this.clearCustomAutoplay();
		this.autoPlayTimer = setInterval(function () {
			this.slider.slickNext();
		}.bind(this), autoPlaySpeed);
	},
	componentDidMount: function componentDidMount() {
		var testimonial = this.props.module;
		if (null != testimonial.get('atts') && !isEmpty(testimonial.getIn(['atts', 'slide_show']))) {
			this.customAutoplay();
		}
	},
	componentDidUpdate: function componentDidUpdate(prevProps) {
		var currentTestimonial = this.props.module,
		    oldTestimonial = prevProps.module,
		    curAutoPlay = currentTestimonial.getIn(['atts', 'slide_show']),
		    oldAutoPlay = oldTestimonial.getIn(['atts', 'slide_show']),
		    curAutoPlaySpeed = currentTestimonial.getIn(['atts', 'slide_show_speed']),
		    oldAutoPlaySpeed = oldTestimonial.getIn(['atts', 'slide_show_speed']);
		if (!isEmpty(oldAutoPlay) && isEmpty(curAutoPlay)) {
			this.clearCustomAutoplay();
		} else if (isEmpty(oldAutoPlay) && !isEmpty(curAutoPlay)) {
			this.customAutoplay();
		} else if (curAutoPlay && oldAutoPlay && oldAutoPlaySpeed != curAutoPlaySpeed) {
			this.customAutoplay();
		}
	},
	render: function render() {
		var testimonials = this.props.module,
		    moduleOptions = this.props.moduleOptions,
		    atts = testimonials.get('atts'),
		    children = testimonials.get('inner') || Immutable.List(),
		    alignment = '',
		    authorFont,
		    authorRoleFont,
		    pagination = '',
		    arrows = '',
		    cssObject = this.props.cssObject,
		    classArray = [],
		    sliderSettings = {
			adaptiveHeight: true,
			prevArrow: React.createElement(PrevArrow, null),
			nextArrow: React.createElement(NextArrow, null),
			appendDots: function appendDots(dots) {
				dots = React.Children.map(dots, function (ele) {
					return React.createElement('li', { className: ele.props.className,
						style: 'slick-active' == ele.props.className ? cssObject.style['.flickity-page-dots .is-selected'] : null
					});
				});
				return React.createElement(
					'ul',
					{ margin: { margin: '0px' } },
					' ',
					dots,
					' '
				);
			}
		},
		    testimonialStyle = 'style1',
		    visibilityClass = generateVisibilityClasses(atts);

classArray.push('tatsu-testimonials', 'be-slider');
		if (!isEmpty(atts)) {
			alignment = atts.get('alignment');
			testimonialStyle = atts.get('style');
			pagination = atts.get('pagination');
			arrows = atts.get('arrows');
			if (!isEmpty(pagination)) {
				classArray.push('slick-dotted');
			}
			authorFont = atts.get('author_font');
			authorRoleFont = atts.get('author_role_font');
			if (!isEmpty(alignment)) {
				classArray.push('tatsu-testimonial-align-' + alignment);
			}
			if (!isEmpty(testimonialStyle)) {
				classArray.push('tatsu-testimonial-' + testimonialStyle);
			}
			if (!isEmpty(pagination)) {
				sliderSettings.dots = true;
			}
			if (!isEmpty(arrows)) {
				sliderSettings.arrows = true;
			} else {
				sliderSettings.arrows = false;
			}
		}
		return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: "tatsu-testimonial-wrap tatsu-module clearfix " + " " + visibilityClass + " " + atts.get('css_classes'), style: jQuery.extend({}, cssObject.style['.tatsu-module'], cssObject.style['root']) }),
			React.createElement(
				Slider,
				{ className: classArray.join(' '),
					ref: function (c) {
						this.slider = c;
					}.bind(this),
					adaptiveHeight: true,
					arrows: sliderSettings.arrows ? true : false,
					dots: sliderSettings.dots ? true : false,
					prevArrow: sliderSettings.arrows ? sliderSettings.prevArrow : null,
					nextArrow: sliderSettings.arrows ? sliderSettings.nextArrow : null,
					appendDots: sliderSettings.dots ? sliderSettings.appendDots : null
				},
				children.map(function (testimonial) {
					return React.createElement(Testimonial, { key: testimonial.get('id'), module: testimonial, moduleOptions: moduleOptions, cssObject: cssObject, alignment: alignment, testimonialStyle: testimonialStyle, keyId: testimonial.get('id'), authorFont: authorFont, authorRoleFont: authorRoleFont });
				})
			)
		);
	}
});
module.exports = Testimonials;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(3), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 772 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, jQuery, generateIdentifierId, generateVisibilityClasses) {

var isEmpty = __webpack_require__(5);
var parseCustomField = __webpack_require__(38);

var TextBlock = React.createClass({
	displayName: 'TextBlock',

getStyle: function getStyle(atts, textBlock, moduleOptions) {

return textStyle;
	},

getWrapperClass: function getWrapperClass(atts) {

var textClass = 'tatsu-text-inner clearfix ';
		if (!isEmpty(atts.get('scroll_to_animate'))) {
			textClass = textClass + 'scrollToFade ';
		}
		return textClass;
	},

renderHelper: function renderHelper(atts, textBlock, moduleOptions) {

var textStyle = this.getStyle(atts, textBlock, moduleOptions),
		    textClass = this.getWrapperClass(atts),
		    dataContent = textBlock.getIn(['atts', 'content']) || '';

var textBlockStyle = this.props.cssObject.style['.tatsu-text-block-wrap .tatsu-text-inner'];

return React.createElement('div', { className: textClass, style: jQuery.extend({}, textStyle, textBlockStyle), dangerouslySetInnerHTML: { __html: parseCustomField(dataContent) } });
	},

dynamicCSS: function dynamicCSS(t_style) {
		var tatsu_style = t_style[".tatsu-text-block-wrap .tatsu-text-inner *"];
		var dynamic_css = '';
		var fontColor = t_style['.tatsu-text-inner *'].color;
		if (typeof fontColor != 'undefined' && fontColor != '') {
			dynamic_css += 'color:' + fontColor + ';';
		}
		if (typeof tatsu_style.fontFamily != 'undefined' && tatsu_style.fontFamily != '') {
			dynamic_css += 'font-family:' + tatsu_style.fontFamily + ';';
		}
		if (typeof tatsu_style.fontSize != 'undefined' && tatsu_style.fontSize != '') {
			dynamic_css += 'font-size:' + tatsu_style.fontSize + ';';
		}
		if (typeof tatsu_style.fontWeight != 'undefined' && tatsu_style.fontWeight != '') {
			dynamic_css += 'font-weight:' + tatsu_style.fontWeight + ';';
		}
		if (typeof tatsu_style.letterSpacing != 'undefined' && tatsu_style.letterSpacing != '') {
			dynamic_css += 'letter-spacing:' + tatsu_style.letterSpacing + ';';
		}
		if (typeof tatsu_style.lineHeight != 'undefined' && tatsu_style.lineHeight != '') {
			dynamic_css += 'line-height:' + tatsu_style.lineHeight + ';';
		}
		if (typeof tatsu_style.textTransform != 'undefined' && tatsu_style.textTransform != '') {
			dynamic_css += 'text-transform:' + tatsu_style.textTransform + ';';
		}
		return dynamic_css;
	},

render: function render() {

var atts = this.props.module.get('atts'),
		    deviceVisibility = atts.get('hide_in'),
		    moduleOptions = this.props.moduleOptions,
		    textBlock = this.props.module,
		    cssObject = this.props.cssObject.style,
		    textBlockWrapStyle = cssObject['.tatsu-text-block-wrap'];
		// 	visibilityClass = '', 
		// 	visibilityArray;

// if( !isEmpty( deviceVisibility ) ) {

return React.createElement(
			'div',
			_extends({}, generateIdentifierId(atts), { className: 'tatsu-module tatsu-text-block-wrap ' + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), style: jQuery.extend({}, textBlockWrapStyle, this.props.cssObject.style['root']) }),
			React.createElement('style', { dangerouslySetInnerHTML: {
					__html: '\n\t\t\t\t\t.be-pb-observer-' + this.props.module.get('id') + ' .tatsu-text-inner *{\n\t\t\t\t\t\t' + this.dynamicCSS(cssObject) + '\n\t\t\t\t\t}\n\t\t\t\t'
				} }),
			this.renderHelper(atts, textBlock, moduleOptions)
		);
	}

});
module.exports = TextBlock;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(4), __webpack_require__(15), __webpack_require__(12)))

/***/ }),
/* 773 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var isEmpty = __webpack_require__(5);

var TitleWithIcon = React.createClass({
    displayName: 'TitleWithIcon',

getCommonClass: function getCommonClass(atts) {

getIconClass: function getIconClass(atts) {

getTitleClass: function getTitleClass(atts) {

var titleClass = 'tatsu-tc ',
            commonClass = this.getCommonClass(atts);
        titleClass = titleClass + commonClass;
        return titleClass;
    },

render: function render() {

var titleWIthIcon = this.props.module,
            atts = titleWIthIcon.get('atts'),
            content = atts.get('content'),
            titleClass = this.getTitleClass(atts),
            cssObject = this.props.cssObject.style,
            gradientClass = this.props.cssObject.class,
            iconStyle = cssObject['.tatsu-ti-icon'],
            iconWrapStyle = cssObject['.tatsu-ti-wrap.circled'],
            iconGradientClass = gradientClass['.tatsu-ti-icon'],
            iconWrapGradientClass = gradientClass['.tatsu-ti-wrap.circled'],
            contentStyle = !isEmpty(cssObject['.tatsu-tc']) ? cssObject['.tatsu-tc'] : cssObject['.tatsu-tc-custom-space'],
            alignment = atts.get('alignment'),
            customSpaceStyle = alignment == 'left' ? cssObject['.tatsu-tc'] : cssObject['.tatsu-tc-custom-space'],
            iconName = this.getIconClass(atts).iconClass,
            commonName = this.getIconClass(atts).commonClass;
        if ('undefined' === typeof content) {
            content = '';
        }

return React.createElement(
            'div',
            _extends({}, generateIdentifierId(atts), { className: "tatsu-module " + generateVisibilityClasses(atts) + " " + atts.get('css_classes'), style: jQuery.extend({}, cssObject['.tatsu-title-icon'], cssObject['root']) }),
            React.createElement(
                'span',
                { className: "tatsu-ti-wrap tatsu-ti " + commonName + ' ' + iconWrapGradientClass, style: iconWrapStyle },
                React.createElement('i', { className: "tatsu-ti tatsu-ti-icon " + iconName + ' ' + iconGradientClass, style: iconStyle })
            ),
            React.createElement('div', { style: customSpaceStyle, className: titleClass, dangerouslySetInnerHTML: { __html: content } })
        );
    }

});
module.exports = TitleWithIcon;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 774 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateVisibilityClasses, generateIdentifierId, jQuery) {

var isEmpty = __webpack_require__(5);
var Typed = __webpack_require__(1458);

var TypedText = React.createClass({
    displayName: 'TypedText',

typed: {},
    options: {
        typeSpeed: 50,
        backSpeed: 50,
        backDelay: 500,
        startDelay: 1000,
        loop: true
    },

componentDidUpdate: function componentDidUpdate(prevProps) {
        var prevTypedText = prevProps.module,
            prevAtts = prevTypedText.get('atts'),
            newTypedText = this.props.module,
            atts = newTypedText.get('atts'),
            loop = atts.get('loop');

if (prevAtts.get('rotated_text') !== atts.get('rotated_text') || prevAtts.get('tag_to_use') !== atts.get('tag_to_use') || prevAtts.get('loop') !== loop) {

if (loop === '1') {
                loop = true;
            } else {
                loop = false;
            }

this.typed.destroy();
            this.options.strings = atts.get('rotated_text').split(",");
            this.options.loop = loop;
            this.typed = new Typed(this.el, this.options);
        }
    },

componentDidMount: function componentDidMount() {
        var typedText = this.props.module,
            atts = typedText.get('atts'),
            loop = atts.get('loop');

if (loop === '1') {
            loop = true;
        } else {
            loop = false;
        }

this.options.strings = atts.get('rotated_text').split(",");
        this.options.loop = loop;
        this.typed = new Typed(this.el, this.options);
    },

render: function render() {

var typedText = this.props.module,
            atts = typedText.get('atts'),
            prefixText = atts.get('prefix_text'),
            rotatedText = atts.get('rotated_text'),
            suffixText = atts.get('suffix_text'),
            TagToUse = atts.get('tag_to_use');

if (isEmpty(prefixText)) {
            prefixText = '';
        } else {
            prefixText = prefixText + ' ';
        }

if (isEmpty(rotatedText)) {
            rotatedText = '';
        }

if (isEmpty(suffixText)) {
            suffixText = '';
        } else {
            suffixText = ' ' + suffixText;
        }

var cssObject = this.props.cssObject.style,
            typedTextStyle = cssObject['.tatsu-typed-text-wrap'],
            rotatedTextStyle = cssObject['.tatsu-typed-rotated-text'],
            cursorStyle = cssObject['.tatsu-typed-text-cursor'],
            wrapperClass = ['tatsu-module', 'tatsu-typed-text-wrap-react'],
            textSizeToUse = atts.get('typed_text_font'),
            visibilityClass = generateVisibilityClasses(atts);

if (!isEmpty(textSizeToUse)) {
            wrapperClass.push(textSizeToUse);
        }

wrapperClass.push(visibilityClass, atts.get('css_classes'));
        return React.createElement(
            TagToUse,
            _extends({}, generateIdentifierId(atts), { className: wrapperClass.join(' '), style: jQuery.extend({}, typedTextStyle, cssObject['root']) }),
            prefixText,
            React.createElement('span', { style: rotatedTextStyle, dangerouslySetInnerHTML: { __html: '' }, ref: function (el) {
                    return this.el = el;
                }.bind(this) }),
            React.createElement(
                'span',
                { className: 'tatsu-typed-text-cursor', style: cursorStyle },
                '|'
            ),
            suffixText
        );
    }
});

module.exports = TypedText;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(12), __webpack_require__(15), __webpack_require__(4)))

/***/ }),
/* 775 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(React, generateIdentifierId, generateVisibilityClasses, jQuery) {

var isEmpty = __webpack_require__(5),
    parseCustomField = __webpack_require__(38),
    Video = React.createClass({
	displayName: 'Video',

getIframe: function getIframe(atts) {

render: function render() {

var video = this.props.module,
		    moduleOptions = this.props.moduleOptions,
		    atts = video.get('atts'),
		    videoClass = 'tatsu-module ',
		    cssObject = this.props.cssObject.style;

return React.createElement('div', _extends({}, generateIdentifierId(atts), { className: videoClass + generateVisibilityClasses(atts) + ' ' + atts.get('css_classes'), dangerouslySetInnerHTML: { __html: this.getIframe(atts) }, style: jQuery.extend({}, cssObject['.tatsu-video'], cssObject['root']) }));
	}

});
module.exports = Video;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(15), __webpack_require__(12), __webpack_require__(4)))

/***/ }),
/* 776 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var Immutable = __webpack_require__(3);
module.exports = function undoable(reducer, config) {

var newconfig = {
		limit: config.limit,
		filter: config.filter || true
	};

return function (state, action) {

state = newconfig.history;
		if ('undefined' == typeof newconfig.history) {
			newconfig.history = createHistory(reducer(state, {}));
			return newconfig.history;
		}

switch (action.type) {

case 'UNDO_ACTION':

var pastSize = newconfig.history.get('past').size,
				    pastState;
				if (0 == pastSize) {
					return newconfig.history;
				} else {
					pastState = newconfig.history.getIn(['past', newconfig.history.get('past').size - 1]);
					newconfig.history = newconfig.history.set('future', newconfig.history.get('future').push(newconfig.history.get('present')));
					newconfig.history = newconfig.history.set('present', pastState);
					newconfig.history = newconfig.history.set('past', newconfig.history.get('past').pop());
					return newconfig.history;
				}

case 'REDO_ACTION':

var futureSize = newconfig.history.get('future').size,
				    futureState,
				    currentPresent;
				if (0 == futureSize) {
					return newconfig.history;
				} else {
					futureState = newconfig.history.getIn(['future', newconfig.history.get('future').size - 1]);
					currentPresent = newconfig.history.get('present');
					newconfig.history = newconfig.history.set('present', futureState);
					newconfig.history = newconfig.history.setIn(['past', newconfig.history.get('past').size], currentPresent);
					newconfig.history = newconfig.history.set('future', newconfig.history.get('future').pop());
					return newconfig.history;
				}

default:

var result = reducer(newconfig.history.get('present'), action);

if (Immutable.is(newconfig.history.get('present'), result)) {
					if ('function' === typeof newconfig.filter && newconfig.filter(action)) {
						newconfig.history = newconfig.history.set('shouldBeAdded', true);
					}
					return newconfig.history;
				}
				if (0 < newconfig.history.get('future').size) {
					newconfig.history = newconfig.history.set('future', newconfig.history.get('future').clear());
				}
				newconfig.history = addHistory(newconfig.history, result, newconfig.limit);
				if ('function' === typeof newconfig.filter && newconfig.filter(action)) {
					newconfig.history = newconfig.history.set('shouldBeAdded', true);
				} else {
					newconfig.history = newconfig.history.set('shouldBeAdded', false);
				}
				return newconfig.history;

}
	};
};

function createHistory(state) {

var y = Immutable.fromJS({
		past: [],
		present: state,
		future: []
	});

return y;
}

function isHistory(newhistory) {

return 'undefined' != typeof newhistory.past && 'undefined' != typeof newhistory.future && !Array.isArray(newhistory.past) && !Array.isArray(newhistory.future);
}

function addHistory(history, state, limit) {

var currentHistorySpace = history.get('past').size + history.get('future').size,
	    newPast;
	if (true === history.get('shouldBeAdded')) {

if (currentHistorySpace >= limit) {
			newPast = history.get('past').slice(1);
			history = history.set('past', newPast.push(history.get('present')));
		} else {
			history = history.set('past', history.get('past').push(history.get('present')));
		}
		history = history.set('present', state);
		return history;
	} else {

return history.set('present', state);
	}
}

/***/ }),
/* 777 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(792), __esModule: true };

/***/ }),
/* 778 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(793), __esModule: true };

/***/ }),
/* 779 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(794), __esModule: true };

/***/ }),
/* 780 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(796), __esModule: true };

/***/ }),
/* 781 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(798), __esModule: true };

/***/ }),
/* 782 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(799), __esModule: true };

/***/ }),
/* 783 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(800), __esModule: true };

/***/ }),
/* 784 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = { "default": __webpack_require__(801), __esModule: true };

/***/ }),
/* 785 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _getPrototypeOf = __webpack_require__(384);

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _getOwnPropertyDescriptor = __webpack_require__(780);

var _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = function get(object, property, receiver) {
  if (object === null) object = Function.prototype;
  var desc = (0, _getOwnPropertyDescriptor2.default)(object, property);

if (desc === undefined) {
    var parent = (0, _getPrototypeOf2.default)(object);

if (parent === null) {
      return undefined;
    } else {
      return get(parent, property, receiver);
    }
  } else if ("value" in desc) {
    return desc.value;
  } else {
    var getter = desc.get;

if (getter === undefined) {
      return undefined;
    }

return getter.call(receiver);
  }
};

/***/ }),
/* 786 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray

var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
  lookup[i] = code[i]
  revLookup[code.charCodeAt(i)] = i
}

// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63

function getLens (b64) {
  var len = b64.length

if (len % 4 > 0) {
    throw new Error('Invalid string. Length must be a multiple of 4')
  }

// Trim off extra bytes after placeholder bytes are found
  // See: https://github.com/beatgammit/base64-js/issues/42
  var validLen = b64.indexOf('=')
  if (validLen === -1) validLen = len

var placeHoldersLen = validLen === len
    ? 0
    : 4 - (validLen % 4)

return [validLen, placeHoldersLen]
}

// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
  var lens = getLens(b64)
  var validLen = lens[0]
  var placeHoldersLen = lens[1]
  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function _byteLength (b64, validLen, placeHoldersLen) {
  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function toByteArray (b64) {
  var tmp
  var lens = getLens(b64)
  var validLen = lens[0]
  var placeHoldersLen = lens[1]

var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))

var curByte = 0

// if there are placeholders, only get up to the last complete 4 chars
  var len = placeHoldersLen > 0
    ? validLen - 4
    : validLen

var i
  for (i = 0; i < len; i += 4) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 18) |
      (revLookup[b64.charCodeAt(i + 1)] << 12) |
      (revLookup[b64.charCodeAt(i + 2)] << 6) |
      revLookup[b64.charCodeAt(i + 3)]
    arr[curByte++] = (tmp >> 16) & 0xFF
    arr[curByte++] = (tmp >> 8) & 0xFF
    arr[curByte++] = tmp & 0xFF
  }

if (placeHoldersLen === 2) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 2) |
      (revLookup[b64.charCodeAt(i + 1)] >> 4)
    arr[curByte++] = tmp & 0xFF
  }

if (placeHoldersLen === 1) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 10) |
      (revLookup[b64.charCodeAt(i + 1)] << 4) |
      (revLookup[b64.charCodeAt(i + 2)] >> 2)
    arr[curByte++] = (tmp >> 8) & 0xFF
    arr[curByte++] = tmp & 0xFF
  }

return arr
}

function tripletToBase64 (num) {
  return lookup[num >> 18 & 0x3F] +
    lookup[num >> 12 & 0x3F] +
    lookup[num >> 6 & 0x3F] +
    lookup[num & 0x3F]
}

function encodeChunk (uint8, start, end) {
  var tmp
  var output = []
  for (var i = start; i < end; i += 3) {
    tmp =
      ((uint8[i] << 16) & 0xFF0000) +
      ((uint8[i + 1] << 8) & 0xFF00) +
      (uint8[i + 2] & 0xFF)
    output.push(tripletToBase64(tmp))
  }
  return output.join('')
}

function fromByteArray (uint8) {
  var tmp
  var len = uint8.length
  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
  var parts = []
  var maxChunkLength = 16383 // must be multiple of 3

// go through the array every three bytes, we'll deal with trailing stuff later
  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
  }

// pad the end with zeros, but make sure to not forget the extra bytes
  if (extraBytes === 1) {
    tmp = uint8[len - 1]
    parts.push(
      lookup[tmp >> 2] +
      lookup[(tmp << 4) & 0x3F] +
      '=='
    )
  } else if (extraBytes === 2) {
    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
    parts.push(
      lookup[tmp >> 10] +
      lookup[(tmp >> 4) & 0x3F] +
      lookup[(tmp << 2) & 0x3F] +
      '='
    )
  }

return parts.join('')
}

/***/ }),
/* 787 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = __webpack_require__(788);

module.exports = function batchProcessorMaker(options) {
    options             = options || {};
    var reporter        = options.reporter;
    var asyncProcess    = utils.getOption(options, "async", true);
    var autoProcess     = utils.getOption(options, "auto", true);

if(autoProcess && !asyncProcess) {
        reporter && reporter.warn("Invalid options combination. auto=true and async=false is invalid. Setting async=true.");
        asyncProcess = true;
    }

var batch = Batch();
    var asyncFrameHandler;
    var isProcessing = false;

function addFunction(level, fn) {
        if(!isProcessing && autoProcess && asyncProcess && batch.size() === 0) {
            // Since this is async, it is guaranteed to be executed after that the fn is added to the batch.
            // This needs to be done before, since we're checking the size of the batch to be 0.
            processBatchAsync();
        }

batch.add(level, fn);
    }

function processBatch() {
        // Save the current batch, and create a new batch so that incoming functions are not added into the currently processing batch.
        // Continue processing until the top-level batch is empty (functions may be added to the new batch while processing, and so on).
        isProcessing = true;
        while (batch.size()) {
            var processingBatch = batch;
            batch = Batch();
            processingBatch.process();
        }
        isProcessing = false;
    }

function forceProcessBatch(localAsyncProcess) {
        if (isProcessing) {
            return;
        }

if(localAsyncProcess === undefined) {
            localAsyncProcess = asyncProcess;
        }

if(asyncFrameHandler) {
            cancelFrame(asyncFrameHandler);
            asyncFrameHandler = null;
        }

if(localAsyncProcess) {
            processBatchAsync();
        } else {
            processBatch();
        }
    }

function processBatchAsync() {
        asyncFrameHandler = requestFrame(processBatch);
    }

function clearBatch() {
        batch           = {};
        batchSize       = 0;
        topLevel        = 0;
        bottomLevel     = 0;
    }

function cancelFrame(listener) {
        // var cancel = window.cancelAnimationFrame || window.mozCancelAnimationFrame || window.webkitCancelAnimationFrame || window.clearTimeout;
        var cancel = clearTimeout;
        return cancel(listener);
    }

return {
        add: addFunction,
        force: forceProcessBatch
    };
};

function Batch() {
    var batch       = {};
    var size        = 0;
    var topLevel    = 0;
    var bottomLevel = 0;

function add(level, fn) {
        if(!fn) {
            fn = level;
            level = 0;
        }

if(level > topLevel) {
            topLevel = level;
        } else if(level < bottomLevel) {
            bottomLevel = level;
        }

if(!batch[level]) {
            batch[level] = [];
        }

batch[level].push(fn);
        size++;
    }

function process() {
        for(var level = bottomLevel; level <= topLevel; level++) {
            var fns = batch[level];

for(var i = 0; i < fns.length; i++) {
                var fn = fns[i];
                fn();
            }
        }
    }

function getSize() {
        return size;
    }

return {
        add: add,
        process: process,
        size: getSize
    };
}

/***/ }),
/* 788 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = module.exports = {};

utils.getOption = getOption;

function getOption(options, name, defaultValue) {
    var value = options[name];

if((value === undefined || value === null) && defaultValue !== undefined) {
        return defaultValue;
    }

return value;
}

/***/ }),
/* 789 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <http://feross.org>
 * @license  MIT
 */
/* eslint-disable no-proto */

var base64 = __webpack_require__(786)
var ieee754 = __webpack_require__(953)
var isArray = __webpack_require__(960)

exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50

/**
 * If `Buffer.TYPED_ARRAY_SUPPORT`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Use Object implementation (most compatible, even IE6)
 *
 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
 * Opera 11.6+, iOS 4.2+.
 *
 * Due to various browser bugs, sometimes the Object implementation will be used even
 * when the browser supports typed arrays.
 *
 * Note:
 *
 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
 *
 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
 *
 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
 *     incorrect length in some situations.

* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
 * get the Object implementation, which is slower but behaves correctly.
 */
Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
  ? global.TYPED_ARRAY_SUPPORT
  : typedArraySupport()

/*
 * Export kMaxLength after typed array support is determined.
 */
exports.kMaxLength = kMaxLength()

function typedArraySupport () {
  try {
    var arr = new Uint8Array(1)
    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
    return arr.foo() === 42 && // typed array instances can be augmented
        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
  } catch (e) {
    return false
  }
}

function kMaxLength () {
  return Buffer.TYPED_ARRAY_SUPPORT
    ? 0x7fffffff
    : 0x3fffffff
}

function createBuffer (that, length) {
  if (kMaxLength() < length) {
    throw new RangeError('Invalid typed array length')
  }
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    // Return an augmented `Uint8Array` instance, for best performance
    that = new Uint8Array(length)
    that.__proto__ = Buffer.prototype
  } else {
    // Fallback: Return an object instance of the Buffer class
    if (that === null) {
      that = new Buffer(length)
    }
    that.length = length
  }

return that
}

/**
 * The Buffer constructor returns instances of `Uint8Array` that have their
 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
 * returns a single octet.
 *
 * The `Uint8Array` prototype remains unmodified.
 */

function Buffer (arg, encodingOrOffset, length) {
  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
    return new Buffer(arg, encodingOrOffset, length)
  }

// Common case.
  if (typeof arg === 'number') {
    if (typeof encodingOrOffset === 'string') {
      throw new Error(
        'If encoding is specified then the first argument must be a string'
      )
    }
    return allocUnsafe(this, arg)
  }
  return from(this, arg, encodingOrOffset, length)
}

Buffer.poolSize = 8192 // not used by this implementation

// TODO: Legacy, not needed anymore. Remove in next major version.
Buffer._augment = function (arr) {
  arr.__proto__ = Buffer.prototype
  return arr
}

function from (that, value, encodingOrOffset, length) {
  if (typeof value === 'number') {
    throw new TypeError('"value" argument must not be a number')
  }

if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
    return fromArrayBuffer(that, value, encodingOrOffset, length)
  }

if (typeof value === 'string') {
    return fromString(that, value, encodingOrOffset)
  }

return fromObject(that, value)
}

/**
 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
 * if value is a number.
 * Buffer.from(str[, encoding])
 * Buffer.from(array)
 * Buffer.from(buffer)
 * Buffer.from(arrayBuffer[, byteOffset[, length]])
 **/
Buffer.from = function (value, encodingOrOffset, length) {
  return from(null, value, encodingOrOffset, length)
}

if (Buffer.TYPED_ARRAY_SUPPORT) {
  Buffer.prototype.__proto__ = Uint8Array.prototype
  Buffer.__proto__ = Uint8Array
  if (typeof Symbol !== 'undefined' && Symbol.species &&
      Buffer[Symbol.species] === Buffer) {
    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
    Object.defineProperty(Buffer, Symbol.species, {
      value: null,
      configurable: true
    })
  }
}

function assertSize (size) {
  if (typeof size !== 'number') {
    throw new TypeError('"size" argument must be a number')
  } else if (size < 0) {
    throw new RangeError('"size" argument must not be negative')
  }
}

function alloc (that, size, fill, encoding) {
  assertSize(size)
  if (size <= 0) {
    return createBuffer(that, size)
  }
  if (fill !== undefined) {
    // Only pay attention to encoding if it's a string. This
    // prevents accidentally sending in a number that would
    // be interpretted as a start offset.
    return typeof encoding === 'string'
      ? createBuffer(that, size).fill(fill, encoding)
      : createBuffer(that, size).fill(fill)
  }
  return createBuffer(that, size)
}

/**
 * Creates a new filled Buffer instance.
 * alloc(size[, fill[, encoding]])
 **/
Buffer.alloc = function (size, fill, encoding) {
  return alloc(null, size, fill, encoding)
}

function allocUnsafe (that, size) {
  assertSize(size)
  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
  if (!Buffer.TYPED_ARRAY_SUPPORT) {
    for (var i = 0; i < size; ++i) {
      that[i] = 0
    }
  }
  return that
}

/**
 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
 * */
Buffer.allocUnsafe = function (size) {
  return allocUnsafe(null, size)
}
/**
 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
 */
Buffer.allocUnsafeSlow = function (size) {
  return allocUnsafe(null, size)
}

function fromString (that, string, encoding) {
  if (typeof encoding !== 'string' || encoding === '') {
    encoding = 'utf8'
  }

if (!Buffer.isEncoding(encoding)) {
    throw new TypeError('"encoding" must be a valid string encoding')
  }

var length = byteLength(string, encoding) | 0
  that = createBuffer(that, length)

var actual = that.write(string, encoding)

if (actual !== length) {
    // Writing a hex string, for example, that contains invalid characters will
    // cause everything after the first invalid character to be ignored. (e.g.
    // 'abxxcd' will be treated as 'ab')
    that = that.slice(0, actual)
  }

return that
}

function fromArrayLike (that, array) {
  var length = array.length < 0 ? 0 : checked(array.length) | 0
  that = createBuffer(that, length)
  for (var i = 0; i < length; i += 1) {
    that[i] = array[i] & 255
  }
  return that
}

function fromArrayBuffer (that, array, byteOffset, length) {
  array.byteLength // this throws if `array` is not a valid ArrayBuffer

if (byteOffset < 0 || array.byteLength < byteOffset) {
    throw new RangeError('\'offset\' is out of bounds')
  }

if (array.byteLength < byteOffset + (length || 0)) {
    throw new RangeError('\'length\' is out of bounds')
  }

if (byteOffset === undefined && length === undefined) {
    array = new Uint8Array(array)
  } else if (length === undefined) {
    array = new Uint8Array(array, byteOffset)
  } else {
    array = new Uint8Array(array, byteOffset, length)
  }

if (Buffer.TYPED_ARRAY_SUPPORT) {
    // Return an augmented `Uint8Array` instance, for best performance
    that = array
    that.__proto__ = Buffer.prototype
  } else {
    // Fallback: Return an object instance of the Buffer class
    that = fromArrayLike(that, array)
  }
  return that
}

function fromObject (that, obj) {
  if (Buffer.isBuffer(obj)) {
    var len = checked(obj.length) | 0
    that = createBuffer(that, len)

if (that.length === 0) {
      return that
    }

obj.copy(that, 0, 0, len)
    return that
  }

if (obj) {
    if ((typeof ArrayBuffer !== 'undefined' &&
        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
      if (typeof obj.length !== 'number' || isnan(obj.length)) {
        return createBuffer(that, 0)
      }
      return fromArrayLike(that, obj)
    }

if (obj.type === 'Buffer' && isArray(obj.data)) {
      return fromArrayLike(that, obj.data)
    }
  }

throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
}

function checked (length) {
  // Note: cannot use `length < kMaxLength()` here because that fails when
  // length is NaN (which is otherwise coerced to zero.)
  if (length >= kMaxLength()) {
    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
  }
  return length | 0
}

function SlowBuffer (length) {
  if (+length != length) { // eslint-disable-line eqeqeq
    length = 0
  }
  return Buffer.alloc(+length)
}

Buffer.isBuffer = function isBuffer (b) {
  return !!(b != null && b._isBuffer)
}

Buffer.compare = function compare (a, b) {
  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
    throw new TypeError('Arguments must be Buffers')
  }

if (a === b) return 0

var x = a.length
  var y = b.length

for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i]
      y = b[i]
      break
    }
  }

if (x < y) return -1
  if (y < x) return 1
  return 0
}

Buffer.isEncoding = function isEncoding (encoding) {
  switch (String(encoding).toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'latin1':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

Buffer.concat = function concat (list, length) {
  if (!isArray(list)) {
    throw new TypeError('"list" argument must be an Array of Buffers')
  }

if (list.length === 0) {
    return Buffer.alloc(0)
  }

var i
  if (length === undefined) {
    length = 0
    for (i = 0; i < list.length; ++i) {
      length += list[i].length
    }
  }

var buffer = Buffer.allocUnsafe(length)
  var pos = 0
  for (i = 0; i < list.length; ++i) {
    var buf = list[i]
    if (!Buffer.isBuffer(buf)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    }
    buf.copy(buffer, pos)
    pos += buf.length
  }
  return buffer
}

function byteLength (string, encoding) {
  if (Buffer.isBuffer(string)) {
    return string.length
  }
  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
    return string.byteLength
  }
  if (typeof string !== 'string') {
    string = '' + string
  }

var len = string.length
  if (len === 0) return 0

// Use a for loop to avoid recursion
  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'ascii':
      case 'latin1':
      case 'binary':
        return len
      case 'utf8':
      case 'utf-8':
      case undefined:
        return utf8ToBytes(string).length
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return len * 2
      case 'hex':
        return len >>> 1
      case 'base64':
        return base64ToBytes(string).length
      default:
        if (loweredCase) return utf8ToBytes(string).length // assume utf8
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}
Buffer.byteLength = byteLength

function slowToString (encoding, start, end) {
  var loweredCase = false

// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
  // property of a typed array.

// This behaves neither like String nor Uint8Array in that we set start/end
  // to their upper/lower bounds if the value passed is out of range.
  // undefined is handled specially as per ECMA-262 6th Edition,
  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
  if (start === undefined || start < 0) {
    start = 0
  }
  // Return early if start > this.length. Done here to prevent potential uint32
  // coercion fail below.
  if (start > this.length) {
    return ''
  }

if (end === undefined || end > this.length) {
    end = this.length
  }

if (end <= 0) {
    return ''
  }

// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
  end >>>= 0
  start >>>= 0

if (end <= start) {
    return ''
  }

if (!encoding) encoding = 'utf8'

while (true) {
    switch (encoding) {
      case 'hex':
        return hexSlice(this, start, end)

case 'utf8':
      case 'utf-8':
        return utf8Slice(this, start, end)

case 'ascii':
        return asciiSlice(this, start, end)

case 'latin1':
      case 'binary':
        return latin1Slice(this, start, end)

case 'base64':
        return base64Slice(this, start, end)

case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return utf16leSlice(this, start, end)

default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = (encoding + '').toLowerCase()
        loweredCase = true
    }
  }
}

// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
// Buffer instances.
Buffer.prototype._isBuffer = true

function swap (b, n, m) {
  var i = b[n]
  b[n] = b[m]
  b[m] = i
}

Buffer.prototype.swap16 = function swap16 () {
  var len = this.length
  if (len % 2 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 16-bits')
  }
  for (var i = 0; i < len; i += 2) {
    swap(this, i, i + 1)
  }
  return this
}

Buffer.prototype.swap32 = function swap32 () {
  var len = this.length
  if (len % 4 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 32-bits')
  }
  for (var i = 0; i < len; i += 4) {
    swap(this, i, i + 3)
    swap(this, i + 1, i + 2)
  }
  return this
}

Buffer.prototype.swap64 = function swap64 () {
  var len = this.length
  if (len % 8 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 64-bits')
  }
  for (var i = 0; i < len; i += 8) {
    swap(this, i, i + 7)
    swap(this, i + 1, i + 6)
    swap(this, i + 2, i + 5)
    swap(this, i + 3, i + 4)
  }
  return this
}

Buffer.prototype.toString = function toString () {
  var length = this.length | 0
  if (length === 0) return ''
  if (arguments.length === 0) return utf8Slice(this, 0, length)
  return slowToString.apply(this, arguments)
}

Buffer.prototype.equals = function equals (b) {
  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
  if (this === b) return true
  return Buffer.compare(this, b) === 0
}

Buffer.prototype.inspect = function inspect () {
  var str = ''
  var max = exports.INSPECT_MAX_BYTES
  if (this.length > 0) {
    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
    if (this.length > max) str += ' ... '
  }
  return '<Buffer ' + str + '>'
}

Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
  if (!Buffer.isBuffer(target)) {
    throw new TypeError('Argument must be a Buffer')
  }

if (start === undefined) {
    start = 0
  }
  if (end === undefined) {
    end = target ? target.length : 0
  }
  if (thisStart === undefined) {
    thisStart = 0
  }
  if (thisEnd === undefined) {
    thisEnd = this.length
  }

if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
    throw new RangeError('out of range index')
  }

if (thisStart >= thisEnd && start >= end) {
    return 0
  }
  if (thisStart >= thisEnd) {
    return -1
  }
  if (start >= end) {
    return 1
  }

start >>>= 0
  end >>>= 0
  thisStart >>>= 0
  thisEnd >>>= 0

if (this === target) return 0

var x = thisEnd - thisStart
  var y = end - start
  var len = Math.min(x, y)

var thisCopy = this.slice(thisStart, thisEnd)
  var targetCopy = target.slice(start, end)

for (var i = 0; i < len; ++i) {
    if (thisCopy[i] !== targetCopy[i]) {
      x = thisCopy[i]
      y = targetCopy[i]
      break
    }
  }

if (x < y) return -1
  if (y < x) return 1
  return 0
}

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
  // Empty buffer means no match
  if (buffer.length === 0) return -1

// Normalize byteOffset
  if (typeof byteOffset === 'string') {
    encoding = byteOffset
    byteOffset = 0
  } else if (byteOffset > 0x7fffffff) {
    byteOffset = 0x7fffffff
  } else if (byteOffset < -0x80000000) {
    byteOffset = -0x80000000
  }
  byteOffset = +byteOffset  // Coerce to Number.
  if (isNaN(byteOffset)) {
    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
    byteOffset = dir ? 0 : (buffer.length - 1)
  }

// Normalize byteOffset: negative offsets start from the end of the buffer
  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
  if (byteOffset >= buffer.length) {
    if (dir) return -1
    else byteOffset = buffer.length - 1
  } else if (byteOffset < 0) {
    if (dir) byteOffset = 0
    else return -1
  }

// Normalize val
  if (typeof val === 'string') {
    val = Buffer.from(val, encoding)
  }

// Finally, search either indexOf (if dir is true) or lastIndexOf
  if (Buffer.isBuffer(val)) {
    // Special case: looking for empty string/buffer always fails
    if (val.length === 0) {
      return -1
    }
    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
  } else if (typeof val === 'number') {
    val = val & 0xFF // Search for a byte value [0-255]
    if (Buffer.TYPED_ARRAY_SUPPORT &&
        typeof Uint8Array.prototype.indexOf === 'function') {
      if (dir) {
        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
      } else {
        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
      }
    }
    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
  }

throw new TypeError('val must be string, number or Buffer')
}

function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
  var indexSize = 1
  var arrLength = arr.length
  var valLength = val.length

if (encoding !== undefined) {
    encoding = String(encoding).toLowerCase()
    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
        encoding === 'utf16le' || encoding === 'utf-16le') {
      if (arr.length < 2 || val.length < 2) {
        return -1
      }
      indexSize = 2
      arrLength /= 2
      valLength /= 2
      byteOffset /= 2
    }
  }

function read (buf, i) {
    if (indexSize === 1) {
      return buf[i]
    } else {
      return buf.readUInt16BE(i * indexSize)
    }
  }

var i
  if (dir) {
    var foundIndex = -1
    for (i = byteOffset; i < arrLength; i++) {
      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
        if (foundIndex === -1) foundIndex = i
        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
      } else {
        if (foundIndex !== -1) i -= i - foundIndex
        foundIndex = -1
      }
    }
  } else {
    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
    for (i = byteOffset; i >= 0; i--) {
      var found = true
      for (var j = 0; j < valLength; j++) {
        if (read(arr, i + j) !== read(val, j)) {
          found = false
          break
        }
      }
      if (found) return i
    }
  }

return -1
}

Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1
}

Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}

Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}

function hexWrite (buf, string, offset, length) {
  offset = Number(offset) || 0
  var remaining = buf.length - offset
  if (!length) {
    length = remaining
  } else {
    length = Number(length)
    if (length > remaining) {
      length = remaining
    }
  }

// must be an even number of digits
  var strLen = string.length
  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')

if (length > strLen / 2) {
    length = strLen / 2
  }
  for (var i = 0; i < length; ++i) {
    var parsed = parseInt(string.substr(i * 2, 2), 16)
    if (isNaN(parsed)) return i
    buf[offset + i] = parsed
  }
  return i
}

function utf8Write (buf, string, offset, length) {
  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}

function asciiWrite (buf, string, offset, length) {
  return blitBuffer(asciiToBytes(string), buf, offset, length)
}

function latin1Write (buf, string, offset, length) {
  return asciiWrite(buf, string, offset, length)
}

function base64Write (buf, string, offset, length) {
  return blitBuffer(base64ToBytes(string), buf, offset, length)
}

function ucs2Write (buf, string, offset, length) {
  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}

Buffer.prototype.write = function write (string, offset, length, encoding) {
  // Buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8'
    length = this.length
    offset = 0
  // Buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset
    length = this.length
    offset = 0
  // Buffer#write(string, offset[, length][, encoding])
  } else if (isFinite(offset)) {
    offset = offset | 0
    if (isFinite(length)) {
      length = length | 0
      if (encoding === undefined) encoding = 'utf8'
    } else {
      encoding = length
      length = undefined
    }
  // legacy write(string, encoding, offset, length) - remove in v0.13
  } else {
    throw new Error(
      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
    )
  }

var remaining = this.length - offset
  if (length === undefined || length > remaining) length = remaining

if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
    throw new RangeError('Attempt to write outside buffer bounds')
  }

if (!encoding) encoding = 'utf8'

var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'hex':
        return hexWrite(this, string, offset, length)

case 'utf8':
      case 'utf-8':
        return utf8Write(this, string, offset, length)

case 'ascii':
        return asciiWrite(this, string, offset, length)

case 'latin1':
      case 'binary':
        return latin1Write(this, string, offset, length)

case 'base64':
        // Warning: maxLength not taken into account in base64Write
        return base64Write(this, string, offset, length)

case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return ucs2Write(this, string, offset, length)

default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}

Buffer.prototype.toJSON = function toJSON () {
  return {
    type: 'Buffer',
    data: Array.prototype.slice.call(this._arr || this, 0)
  }
}

function base64Slice (buf, start, end) {
  if (start === 0 && end === buf.length) {
    return base64.fromByteArray(buf)
  } else {
    return base64.fromByteArray(buf.slice(start, end))
  }
}

function utf8Slice (buf, start, end) {
  end = Math.min(buf.length, end)
  var res = []

var i = start
  while (i < end) {
    var firstByte = buf[i]
    var codePoint = null
    var bytesPerSequence = (firstByte > 0xEF) ? 4
      : (firstByte > 0xDF) ? 3
      : (firstByte > 0xBF) ? 2
      : 1

if (i + bytesPerSequence <= end) {
      var secondByte, thirdByte, fourthByte, tempCodePoint

switch (bytesPerSequence) {
        case 1:
          if (firstByte < 0x80) {
            codePoint = firstByte
          }
          break
        case 2:
          secondByte = buf[i + 1]
          if ((secondByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
            if (tempCodePoint > 0x7F) {
              codePoint = tempCodePoint
            }
          }
          break
        case 3:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
              codePoint = tempCodePoint
            }
          }
          break
        case 4:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          fourthByte = buf[i + 3]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
              codePoint = tempCodePoint
            }
          }
      }
    }

if (codePoint === null) {
      // we did not generate a valid codePoint so insert a
      // replacement char (U+FFFD) and advance only 1 byte
      codePoint = 0xFFFD
      bytesPerSequence = 1
    } else if (codePoint > 0xFFFF) {
      // encode to utf16 (surrogate pair dance)
      codePoint -= 0x10000
      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
      codePoint = 0xDC00 | codePoint & 0x3FF
    }

res.push(codePoint)
    i += bytesPerSequence
  }

return decodeCodePointsArray(res)
}

// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000

function decodeCodePointsArray (codePoints) {
  var len = codePoints.length
  if (len <= MAX_ARGUMENTS_LENGTH) {
    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
  }

// Decode in chunks to avoid "call stack size exceeded".
  var res = ''
  var i = 0
  while (i < len) {
    res += String.fromCharCode.apply(
      String,
      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
    )
  }
  return res
}

function asciiSlice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i] & 0x7F)
  }
  return ret
}

function latin1Slice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i])
  }
  return ret
}

function hexSlice (buf, start, end) {
  var len = buf.length

if (!start || start < 0) start = 0
  if (!end || end < 0 || end > len) end = len

var out = ''
  for (var i = start; i < end; ++i) {
    out += toHex(buf[i])
  }
  return out
}

function utf16leSlice (buf, start, end) {
  var bytes = buf.slice(start, end)
  var res = ''
  for (var i = 0; i < bytes.length; i += 2) {
    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
  }
  return res
}

Buffer.prototype.slice = function slice (start, end) {
  var len = this.length
  start = ~~start
  end = end === undefined ? len : ~~end

if (start < 0) {
    start += len
    if (start < 0) start = 0
  } else if (start > len) {
    start = len
  }

if (end < 0) {
    end += len
    if (end < 0) end = 0
  } else if (end > len) {
    end = len
  }

if (end < start) end = start

var newBuf
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    newBuf = this.subarray(start, end)
    newBuf.__proto__ = Buffer.prototype
  } else {
    var sliceLen = end - start
    newBuf = new Buffer(sliceLen, undefined)
    for (var i = 0; i < sliceLen; ++i) {
      newBuf[i] = this[i + start]
    }
  }

return newBuf
}

/*
 * Need to make sure that buffer isn't trying to write out of bounds.
 */
function checkOffset (offset, ext, length) {
  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}

Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }

return val
}

Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) {
    checkOffset(offset, byteLength, this.length)
  }

var val = this[offset + --byteLength]
  var mul = 1
  while (byteLength > 0 && (mul *= 0x100)) {
    val += this[offset + --byteLength] * mul
  }

return val
}

Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 1, this.length)
  return this[offset]
}

Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length)
  return this[offset] | (this[offset + 1] << 8)
}

Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length)
  return (this[offset] << 8) | this[offset + 1]
}

Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)

return ((this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16)) +
      (this[offset + 3] * 0x1000000)
}

Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)

return (this[offset] * 0x1000000) +
    ((this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    this[offset + 3])
}

Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }
  mul *= 0x80

if (val >= mul) val -= Math.pow(2, 8 * byteLength)

return val
}

Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

var i = byteLength
  var mul = 1
  var val = this[offset + --i]
  while (i > 0 && (mul *= 0x100)) {
    val += this[offset + --i] * mul
  }
  mul *= 0x80

if (val >= mul) val -= Math.pow(2, 8 * byteLength)

return val
}

Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 1, this.length)
  if (!(this[offset] & 0x80)) return (this[offset])
  return ((0xff - this[offset] + 1) * -1)
}

Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset] | (this[offset + 1] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset + 1] | (this[offset] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)

return (this[offset]) |
    (this[offset + 1] << 8) |
    (this[offset + 2] << 16) |
    (this[offset + 3] << 24)
}

Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)

return (this[offset] << 24) |
    (this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    (this[offset + 3])
}

Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, true, 23, 4)
}

Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, false, 23, 4)
}

Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, true, 52, 8)
}

Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, false, 52, 8)
}

function checkInt (buf, value, offset, ext, max, min) {
  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
}

Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

var mul = 1
  var i = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

return offset + byteLength
}

Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

var i = byteLength - 1
  var mul = 1
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

return offset + byteLength
}

Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
  this[offset] = (value & 0xff)
  return offset + 1
}

function objectWriteUInt16 (buf, value, offset, littleEndian) {
  if (value < 0) value = 0xffff + value + 1
  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
      (littleEndian ? i : 1 - i) * 8
  }
}

Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
  } else {
    objectWriteUInt16(this, value, offset, true)
  }
  return offset + 2
}

Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
  } else {
    objectWriteUInt16(this, value, offset, false)
  }
  return offset + 2
}

function objectWriteUInt32 (buf, value, offset, littleEndian) {
  if (value < 0) value = 0xffffffff + value + 1
  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
  }
}

Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset + 3] = (value >>> 24)
    this[offset + 2] = (value >>> 16)
    this[offset + 1] = (value >>> 8)
    this[offset] = (value & 0xff)
  } else {
    objectWriteUInt32(this, value, offset, true)
  }
  return offset + 4
}

Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
  } else {
    objectWriteUInt32(this, value, offset, false)
  }
  return offset + 4
}

Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) {
    var limit = Math.pow(2, 8 * byteLength - 1)

checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

var i = 0
  var mul = 1
  var sub = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

return offset + byteLength
}

Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) {
    var limit = Math.pow(2, 8 * byteLength - 1)

checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

var i = byteLength - 1
  var mul = 1
  var sub = 0
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

return offset + byteLength
}

Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
  if (value < 0) value = 0xff + value + 1
  this[offset] = (value & 0xff)
  return offset + 1
}

Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
  } else {
    objectWriteUInt16(this, value, offset, true)
  }
  return offset + 2
}

Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
  } else {
    objectWriteUInt16(this, value, offset, false)
  }
  return offset + 2
}

Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    this[offset + 2] = (value >>> 16)
    this[offset + 3] = (value >>> 24)
  } else {
    objectWriteUInt32(this, value, offset, true)
  }
  return offset + 4
}

Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (value < 0) value = 0xffffffff + value + 1
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
  } else {
    objectWriteUInt32(this, value, offset, false)
  }
  return offset + 4
}

function checkIEEE754 (buf, value, offset, ext, max, min) {
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
  if (offset < 0) throw new RangeError('Index out of range')
}

function writeFloat (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
  }
  ieee754.write(buf, value, offset, littleEndian, 23, 4)
  return offset + 4
}

Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
  return writeFloat(this, value, offset, true, noAssert)
}

Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
  return writeFloat(this, value, offset, false, noAssert)
}

function writeDouble (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
  }
  ieee754.write(buf, value, offset, littleEndian, 52, 8)
  return offset + 8
}

Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
  return writeDouble(this, value, offset, true, noAssert)
}

Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
  return writeDouble(this, value, offset, false, noAssert)
}

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
  if (!start) start = 0
  if (!end && end !== 0) end = this.length
  if (targetStart >= target.length) targetStart = target.length
  if (!targetStart) targetStart = 0
  if (end > 0 && end < start) end = start

// Copy 0 bytes; we're done
  if (end === start) return 0
  if (target.length === 0 || this.length === 0) return 0

// Fatal error conditions
  if (targetStart < 0) {
    throw new RangeError('targetStart out of bounds')
  }
  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
  if (end < 0) throw new RangeError('sourceEnd out of bounds')

// Are we oob?
  if (end > this.length) end = this.length
  if (target.length - targetStart < end - start) {
    end = target.length - targetStart + start
  }

var len = end - start
  var i

if (this === target && start < targetStart && targetStart < end) {
    // descending copy from end
    for (i = len - 1; i >= 0; --i) {
      target[i + targetStart] = this[i + start]
    }
  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
    // ascending copy from start
    for (i = 0; i < len; ++i) {
      target[i + targetStart] = this[i + start]
    }
  } else {
    Uint8Array.prototype.set.call(
      target,
      this.subarray(start, start + len),
      targetStart
    )
  }

return len
}

// Usage:
//    buffer.fill(number[, offset[, end]])
//    buffer.fill(buffer[, offset[, end]])
//    buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
  // Handle string cases:
  if (typeof val === 'string') {
    if (typeof start === 'string') {
      encoding = start
      start = 0
      end = this.length
    } else if (typeof end === 'string') {
      encoding = end
      end = this.length
    }
    if (val.length === 1) {
      var code = val.charCodeAt(0)
      if (code < 256) {
        val = code
      }
    }
    if (encoding !== undefined && typeof encoding !== 'string') {
      throw new TypeError('encoding must be a string')
    }
    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding)
    }
  } else if (typeof val === 'number') {
    val = val & 255
  }

// Invalid ranges are not set to a default, so can range check early.
  if (start < 0 || this.length < start || this.length < end) {
    throw new RangeError('Out of range index')
  }

if (end <= start) {
    return this
  }

start = start >>> 0
  end = end === undefined ? this.length : end >>> 0

if (!val) val = 0

var i
  if (typeof val === 'number') {
    for (i = start; i < end; ++i) {
      this[i] = val
    }
  } else {
    var bytes = Buffer.isBuffer(val)
      ? val
      : utf8ToBytes(new Buffer(val, encoding).toString())
    var len = bytes.length
    for (i = 0; i < end - start; ++i) {
      this[i + start] = bytes[i % len]
    }
  }

return this
}

// HELPER FUNCTIONS
// ================

var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g

function base64clean (str) {
  // Node strips out invalid characters like \n and \t from the string, base64-js does not
  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
  // Node converts strings with length < 2 to ''
  if (str.length < 2) return ''
  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
  while (str.length % 4 !== 0) {
    str = str + '='
  }
  return str
}

function stringtrim (str) {
  if (str.trim) return str.trim()
  return str.replace(/^\s+|\s+$/g, '')
}

function toHex (n) {
  if (n < 16) return '0' + n.toString(16)
  return n.toString(16)
}

function utf8ToBytes (string, units) {
  units = units || Infinity
  var codePoint
  var length = string.length
  var leadSurrogate = null
  var bytes = []

for (var i = 0; i < length; ++i) {
    codePoint = string.charCodeAt(i)

// is surrogate component
    if (codePoint > 0xD7FF && codePoint < 0xE000) {
      // last char was a lead
      if (!leadSurrogate) {
        // no lead yet
        if (codePoint > 0xDBFF) {
          // unexpected trail
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        } else if (i + 1 === length) {
          // unpaired lead
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        }

// valid lead
        leadSurrogate = codePoint

continue
      }

// 2 leads in a row
      if (codePoint < 0xDC00) {
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
        leadSurrogate = codePoint
        continue
      }

// valid surrogate pair
      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
    } else if (leadSurrogate) {
      // valid bmp char, but last char was a lead
      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
    }

leadSurrogate = null

// encode utf8
    if (codePoint < 0x80) {
      if ((units -= 1) < 0) break
      bytes.push(codePoint)
    } else if (codePoint < 0x800) {
      if ((units -= 2) < 0) break
      bytes.push(
        codePoint >> 0x6 | 0xC0,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x10000) {
      if ((units -= 3) < 0) break
      bytes.push(
        codePoint >> 0xC | 0xE0,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x110000) {
      if ((units -= 4) < 0) break
      bytes.push(
        codePoint >> 0x12 | 0xF0,
        codePoint >> 0xC & 0x3F | 0x80,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else {
      throw new Error('Invalid code point')
    }
  }

return bytes
}

function asciiToBytes (str) {
  var byteArray = []
  for (var i = 0; i < str.length; ++i) {
    // Node's code seems to be doing this and not & 0x7F..
    byteArray.push(str.charCodeAt(i) & 0xFF)
  }
  return byteArray
}

function utf16leToBytes (str, units) {
  var c, hi, lo
  var byteArray = []
  for (var i = 0; i < str.length; ++i) {
    if ((units -= 2) < 0) break

c = str.charCodeAt(i)
    hi = c >> 8
    lo = c % 256
    byteArray.push(lo)
    byteArray.push(hi)
  }

return byteArray
}

function base64ToBytes (str) {
  return base64.toByteArray(base64clean(str))
}

function blitBuffer (src, dst, offset, length) {
  for (var i = 0; i < length; ++i) {
    if ((i + offset >= dst.length) || (i >= src.length)) break
    dst[i + offset] = src[i]
  }
  return i
}

function isnan (val) {
  return val !== val // eslint-disable-line no-self-compare
}

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 790 */
/***/ (function(module, exports, __webpack_require__) {

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE

(function(mod) {
  if (true) // CommonJS
    mod(__webpack_require__(244));
  else if (typeof define == "function" && define.amd) // AMD
    define(["../../lib/codemirror"], mod);
  else // Plain browser env
    mod(CodeMirror);
})(function(CodeMirror) {
"use strict";

CodeMirror.defineMode("css", function(config, parserConfig) {
  var inline = parserConfig.inline
  if (!parserConfig.propertyKeywords) parserConfig = CodeMirror.resolveMode("text/css");

var indentUnit = config.indentUnit,
      tokenHooks = parserConfig.tokenHooks,
      documentTypes = parserConfig.documentTypes || {},
      mediaTypes = parserConfig.mediaTypes || {},
      mediaFeatures = parserConfig.mediaFeatures || {},
      mediaValueKeywords = parserConfig.mediaValueKeywords || {},
      propertyKeywords = parserConfig.propertyKeywords || {},
      nonStandardPropertyKeywords = parserConfig.nonStandardPropertyKeywords || {},
      fontProperties = parserConfig.fontProperties || {},
      counterDescriptors = parserConfig.counterDescriptors || {},
      colorKeywords = parserConfig.colorKeywords || {},
      valueKeywords = parserConfig.valueKeywords || {},
      allowNested = parserConfig.allowNested,
      lineComment = parserConfig.lineComment,
      supportsAtComponent = parserConfig.supportsAtComponent === true;

var type, override;
  function ret(style, tp) { type = tp; return style; }

// Tokenizers

function tokenParenthesized(stream, state) {
    stream.next(); // Must be '('
    if (!stream.match(/\s*[\"\')]/, false))
      state.tokenize = tokenString(")");
    else
      state.tokenize = null;
    return ret(null, "(");
  }

// Context management

function Context(type, indent, prev) {
    this.type = type;
    this.indent = indent;
    this.prev = prev;
  }

function pushContext(state, stream, type, indent) {
    state.context = new Context(type, stream.indentation() + (indent === false ? 0 : indentUnit), state.context);
    return type;
  }

function popContext(state) {
    if (state.context.prev)
      state.context = state.context.prev;
    return state.context.type;
  }

function pass(type, stream, state) {
    return states[state.context.type](type, stream, state);
  }
  function popAndPass(type, stream, state, n) {
    for (var i = n || 1; i > 0; i--)
      state.context = state.context.prev;
    return pass(type, stream, state);
  }

// Parser

function wordAsValue(stream) {
    var word = stream.current().toLowerCase();
    if (valueKeywords.hasOwnProperty(word))
      override = "atom";
    else if (colorKeywords.hasOwnProperty(word))
      override = "keyword";
    else
      override = "variable";
  }

var states = {};

states.top = function(type, stream, state) {
    if (type == "{") {
      return pushContext(state, stream, "block");
    } else if (type == "}" && state.context.prev) {
      return popContext(state);
    } else if (supportsAtComponent && /@component/i.test(type)) {
      return pushContext(state, stream, "atComponentBlock");
    } else if (/^@(-moz-)?document$/i.test(type)) {
      return pushContext(state, stream, "documentTypes");
    } else if (/^@(media|supports|(-moz-)?document|import)$/i.test(type)) {
      return pushContext(state, stream, "atBlock");
    } else if (/^@(font-face|counter-style)/i.test(type)) {
      state.stateArg = type;
      return "restricted_atBlock_before";
    } else if (/^@(-(moz|ms|o|webkit)-)?keyframes$/i.test(type)) {
      return "keyframes";
    } else if (type && type.charAt(0) == "@") {
      return pushContext(state, stream, "at");
    } else if (type == "hash") {
      override = "builtin";
    } else if (type == "word") {
      override = "tag";
    } else if (type == "variable-definition") {
      return "maybeprop";
    } else if (type == "interpolation") {
      return pushContext(state, stream, "interpolation");
    } else if (type == ":") {
      return "pseudo";
    } else if (allowNested && type == "(") {
      return pushContext(state, stream, "parens");
    }
    return state.context.type;
  };

states.block = function(type, stream, state) {
    if (type == "word") {
      var word = stream.current().toLowerCase();
      if (propertyKeywords.hasOwnProperty(word)) {
        override = "property";
        return "maybeprop";
      } else if (nonStandardPropertyKeywords.hasOwnProperty(word)) {
        override = "string-2";
        return "maybeprop";
      } else if (allowNested) {
        override = stream.match(/^\s*:(?:\s|$)/, false) ? "property" : "tag";
        return "block";
      } else {
        override += " error";
        return "maybeprop";
      }
    } else if (type == "meta") {
      return "block";
    } else if (!allowNested && (type == "hash" || type == "qualifier")) {
      override = "error";
      return "block";
    } else {
      return states.top(type, stream, state);
    }
  };

states.maybeprop = function(type, stream, state) {
    if (type == ":") return pushContext(state, stream, "prop");
    return pass(type, stream, state);
  };

states.prop = function(type, stream, state) {
    if (type == ";") return popContext(state);
    if (type == "{" && allowNested) return pushContext(state, stream, "propBlock");
    if (type == "}" || type == "{") return popAndPass(type, stream, state);
    if (type == "(") return pushContext(state, stream, "parens");

if (type == "hash" && !/^#([0-9a-fA-f]{3,4}|[0-9a-fA-f]{6}|[0-9a-fA-f]{8})$/.test(stream.current())) {
      override += " error";
    } else if (type == "word") {
      wordAsValue(stream);
    } else if (type == "interpolation") {
      return pushContext(state, stream, "interpolation");
    }
    return "prop";
  };

states.propBlock = function(type, _stream, state) {
    if (type == "}") return popContext(state);
    if (type == "word") { override = "property"; return "maybeprop"; }
    return state.context.type;
  };

states.parens = function(type, stream, state) {
    if (type == "{" || type == "}") return popAndPass(type, stream, state);
    if (type == ")") return popContext(state);
    if (type == "(") return pushContext(state, stream, "parens");
    if (type == "interpolation") return pushContext(state, stream, "interpolation");
    if (type == "word") wordAsValue(stream);
    return "parens";
  };

states.pseudo = function(type, stream, state) {
    if (type == "meta") return "pseudo";

if (type == "word") {
      override = "variable-3";
      return state.context.type;
    }
    return pass(type, stream, state);
  };

states.documentTypes = function(type, stream, state) {
    if (type == "word" && documentTypes.hasOwnProperty(stream.current())) {
      override = "tag";
      return state.context.type;
    } else {
      return states.atBlock(type, stream, state);
    }
  };

states.atBlock = function(type, stream, state) {
    if (type == "(") return pushContext(state, stream, "atBlock_parens");
    if (type == "}" || type == ";") return popAndPass(type, stream, state);
    if (type == "{") return popContext(state) && pushContext(state, stream, allowNested ? "block" : "top");

if (type == "interpolation") return pushContext(state, stream, "interpolation");

if (type == "word") {
      var word = stream.current().toLowerCase();
      if (word == "only" || word == "not" || word == "and" || word == "or")
        override = "keyword";
      else if (mediaTypes.hasOwnProperty(word))
        override = "attribute";
      else if (mediaFeatures.hasOwnProperty(word))
        override = "property";
      else if (mediaValueKeywords.hasOwnProperty(word))
        override = "keyword";
      else if (propertyKeywords.hasOwnProperty(word))
        override = "property";
      else if (nonStandardPropertyKeywords.hasOwnProperty(word))
        override = "string-2";
      else if (valueKeywords.hasOwnProperty(word))
        override = "atom";
      else if (colorKeywords.hasOwnProperty(word))
        override = "keyword";
      else
        override = "error";
    }
    return state.context.type;
  };

states.atComponentBlock = function(type, stream, state) {
    if (type == "}")
      return popAndPass(type, stream, state);
    if (type == "{")
      return popContext(state) && pushContext(state, stream, allowNested ? "block" : "top", false);
    if (type == "word")
      override = "error";
    return state.context.type;
  };

states.atBlock_parens = function(type, stream, state) {
    if (type == ")") return popContext(state);
    if (type == "{" || type == "}") return popAndPass(type, stream, state, 2);
    return states.atBlock(type, stream, state);
  };

states.restricted_atBlock_before = function(type, stream, state) {
    if (type == "{")
      return pushContext(state, stream, "restricted_atBlock");
    if (type == "word" && state.stateArg == "@counter-style") {
      override = "variable";
      return "restricted_atBlock_before";
    }
    return pass(type, stream, state);
  };

states.restricted_atBlock = function(type, stream, state) {
    if (type == "}") {
      state.stateArg = null;
      return popContext(state);
    }
    if (type == "word") {
      if ((state.stateArg == "@font-face" && !fontProperties.hasOwnProperty(stream.current().toLowerCase())) ||
          (state.stateArg == "@counter-style" && !counterDescriptors.hasOwnProperty(stream.current().toLowerCase())))
        override = "error";
      else
        override = "property";
      return "maybeprop";
    }
    return "restricted_atBlock";
  };

states.keyframes = function(type, stream, state) {
    if (type == "word") { override = "variable"; return "keyframes"; }
    if (type == "{") return pushContext(state, stream, "top");
    return pass(type, stream, state);
  };

states.at = function(type, stream, state) {
    if (type == ";") return popContext(state);
    if (type == "{" || type == "}") return popAndPass(type, stream, state);
    if (type == "word") override = "tag";
    else if (type == "hash") override = "builtin";
    return "at";
  };

states.interpolation = function(type, stream, state) {
    if (type == "}") return popContext(state);
    if (type == "{" || type == ";") return popAndPass(type, stream, state);
    if (type == "word") override = "variable";
    else if (type != "variable" && type != "(" && type != ")") override = "error";
    return "interpolation";
  };

return {
    startState: function(base) {
      return {tokenize: null,
              state: inline ? "block" : "top",
              stateArg: null,
              context: new Context(inline ? "block" : "top", base || 0, null)};
    },

token: function(stream, state) {
      if (!state.tokenize && stream.eatSpace()) return null;
      var style = (state.tokenize || tokenBase)(stream, state);
      if (style && typeof style == "object") {
        type = style[1];
        style = style[0];
      }
      override = style;
      if (type != "comment")
        state.state = states[state.state](type, stream, state);
      return override;
    },

indent: function(state, textAfter) {
      var cx = state.context, ch = textAfter && textAfter.charAt(0);
      var indent = cx.indent;
      if (cx.type == "prop" && (ch == "}" || ch == ")")) cx = cx.prev;
      if (cx.prev) {
        if (ch == "}" && (cx.type == "block" || cx.type == "top" ||
                          cx.type == "interpolation" || cx.type == "restricted_atBlock")) {
          // Resume indentation from parent context.
          cx = cx.prev;
          indent = cx.indent;
        } else if (ch == ")" && (cx.type == "parens" || cx.type == "atBlock_parens") ||
            ch == "{" && (cx.type == "at" || cx.type == "atBlock")) {
          // Dedent relative to current context.
          indent = Math.max(0, cx.indent - indentUnit);
        }
      }
      return indent;
    },

electricChars: "}",
    blockCommentStart: "/*",
    blockCommentEnd: "*/",
    blockCommentContinue: " * ",
    lineComment: lineComment,
    fold: "brace"
  };
});

function keySet(array) {
    var keys = {};
    for (var i = 0; i < array.length; ++i) {
      keys[array[i].toLowerCase()] = true;
    }
    return keys;
  }

var documentTypes_ = [
    "domain", "regexp", "url", "url-prefix"
  ], documentTypes = keySet(documentTypes_);

var mediaTypes_ = [
    "all", "aural", "braille", "handheld", "print", "projection", "screen",
    "tty", "tv", "embossed"
  ], mediaTypes = keySet(mediaTypes_);

var mediaFeatures_ = [
    "width", "min-width", "max-width", "height", "min-height", "max-height",
    "device-width", "min-device-width", "max-device-width", "device-height",
    "min-device-height", "max-device-height", "aspect-ratio",
    "min-aspect-ratio", "max-aspect-ratio", "device-aspect-ratio",
    "min-device-aspect-ratio", "max-device-aspect-ratio", "color", "min-color",
    "max-color", "color-index", "min-color-index", "max-color-index",
    "monochrome", "min-monochrome", "max-monochrome", "resolution",
    "min-resolution", "max-resolution", "scan", "grid", "orientation",
    "device-pixel-ratio", "min-device-pixel-ratio", "max-device-pixel-ratio",
    "pointer", "any-pointer", "hover", "any-hover"
  ], mediaFeatures = keySet(mediaFeatures_);

var mediaValueKeywords_ = [
    "landscape", "portrait", "none", "coarse", "fine", "on-demand", "hover",
    "interlace", "progressive"
  ], mediaValueKeywords = keySet(mediaValueKeywords_);

var propertyKeywords_ = [
    "align-content", "align-items", "align-self", "alignment-adjust",
    "alignment-baseline", "anchor-point", "animation", "animation-delay",
    "animation-direction", "animation-duration", "animation-fill-mode",
    "animation-iteration-count", "animation-name", "animation-play-state",
    "animation-timing-function", "appearance", "azimuth", "backface-visibility",
    "background", "background-attachment", "background-blend-mode", "background-clip",
    "background-color", "background-image", "background-origin", "background-position",
    "background-repeat", "background-size", "baseline-shift", "binding",
    "bleed", "bookmark-label", "bookmark-level", "bookmark-state",
    "bookmark-target", "border", "border-bottom", "border-bottom-color",
    "border-bottom-left-radius", "border-bottom-right-radius",
    "border-bottom-style", "border-bottom-width", "border-collapse",
    "border-color", "border-image", "border-image-outset",
    "border-image-repeat", "border-image-slice", "border-image-source",
    "border-image-width", "border-left", "border-left-color",
    "border-left-style", "border-left-width", "border-radius", "border-right",
    "border-right-color", "border-right-style", "border-right-width",
    "border-spacing", "border-style", "border-top", "border-top-color",
    "border-top-left-radius", "border-top-right-radius", "border-top-style",
    "border-top-width", "border-width", "bottom", "box-decoration-break",
    "box-shadow", "box-sizing", "break-after", "break-before", "break-inside",
    "caption-side", "caret-color", "clear", "clip", "color", "color-profile", "column-count",
    "column-fill", "column-gap", "column-rule", "column-rule-color",
    "column-rule-style", "column-rule-width", "column-span", "column-width",
    "columns", "content", "counter-increment", "counter-reset", "crop", "cue",
    "cue-after", "cue-before", "cursor", "direction", "display",
    "dominant-baseline", "drop-initial-after-adjust",
    "drop-initial-after-align", "drop-initial-before-adjust",
    "drop-initial-before-align", "drop-initial-size", "drop-initial-value",
    "elevation", "empty-cells", "fit", "fit-position", "flex", "flex-basis",
    "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap",
    "float", "float-offset", "flow-from", "flow-into", "font", "font-feature-settings",
    "font-family", "font-kerning", "font-language-override", "font-size", "font-size-adjust",
    "font-stretch", "font-style", "font-synthesis", "font-variant",
    "font-variant-alternates", "font-variant-caps", "font-variant-east-asian",
    "font-variant-ligatures", "font-variant-numeric", "font-variant-position",
    "font-weight", "grid", "grid-area", "grid-auto-columns", "grid-auto-flow",
    "grid-auto-rows", "grid-column", "grid-column-end", "grid-column-gap",
    "grid-column-start", "grid-gap", "grid-row", "grid-row-end", "grid-row-gap",
    "grid-row-start", "grid-template", "grid-template-areas", "grid-template-columns",
    "grid-template-rows", "hanging-punctuation", "height", "hyphens",
    "icon", "image-orientation", "image-rendering", "image-resolution",
    "inline-box-align", "justify-content", "justify-items", "justify-self", "left", "letter-spacing",
    "line-break", "line-height", "line-stacking", "line-stacking-ruby",
    "line-stacking-shift", "line-stacking-strategy", "list-style",
    "list-style-image", "list-style-position", "list-style-type", "margin",
    "margin-bottom", "margin-left", "margin-right", "margin-top",
    "marks", "marquee-direction", "marquee-loop",
    "marquee-play-count", "marquee-speed", "marquee-style", "max-height",
    "max-width", "min-height", "min-width", "mix-blend-mode", "move-to", "nav-down", "nav-index",
    "nav-left", "nav-right", "nav-up", "object-fit", "object-position",
    "opacity", "order", "orphans", "outline",
    "outline-color", "outline-offset", "outline-style", "outline-width",
    "overflow", "overflow-style", "overflow-wrap", "overflow-x", "overflow-y",
    "padding", "padding-bottom", "padding-left", "padding-right", "padding-top",
    "page", "page-break-after", "page-break-before", "page-break-inside",
    "page-policy", "pause", "pause-after", "pause-before", "perspective",
    "perspective-origin", "pitch", "pitch-range", "place-content", "place-items", "place-self", "play-during", "position",
    "presentation-level", "punctuation-trim", "quotes", "region-break-after",
    "region-break-before", "region-break-inside", "region-fragment",
    "rendering-intent", "resize", "rest", "rest-after", "rest-before", "richness",
    "right", "rotation", "rotation-point", "ruby-align", "ruby-overhang",
    "ruby-position", "ruby-span", "shape-image-threshold", "shape-inside", "shape-margin",
    "shape-outside", "size", "speak", "speak-as", "speak-header",
    "speak-numeral", "speak-punctuation", "speech-rate", "stress", "string-set",
    "tab-size", "table-layout", "target", "target-name", "target-new",
    "target-position", "text-align", "text-align-last", "text-decoration",
    "text-decoration-color", "text-decoration-line", "text-decoration-skip",
    "text-decoration-style", "text-emphasis", "text-emphasis-color",
    "text-emphasis-position", "text-emphasis-style", "text-height",
    "text-indent", "text-justify", "text-outline", "text-overflow", "text-shadow",
    "text-size-adjust", "text-space-collapse", "text-transform", "text-underline-position",
    "text-wrap", "top", "transform", "transform-origin", "transform-style",
    "transition", "transition-delay", "transition-duration",
    "transition-property", "transition-timing-function", "unicode-bidi",
    "user-select", "vertical-align", "visibility", "voice-balance", "voice-duration",
    "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress",
    "voice-volume", "volume", "white-space", "widows", "width", "will-change", "word-break",
    "word-spacing", "word-wrap", "z-index",
    // SVG-specific
    "clip-path", "clip-rule", "mask", "enable-background", "filter", "flood-color",
    "flood-opacity", "lighting-color", "stop-color", "stop-opacity", "pointer-events",
    "color-interpolation", "color-interpolation-filters",
    "color-rendering", "fill", "fill-opacity", "fill-rule", "image-rendering",
    "marker", "marker-end", "marker-mid", "marker-start", "shape-rendering", "stroke",
    "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin",
    "stroke-miterlimit", "stroke-opacity", "stroke-width", "text-rendering",
    "baseline-shift", "dominant-baseline", "glyph-orientation-horizontal",
    "glyph-orientation-vertical", "text-anchor", "writing-mode"
  ], propertyKeywords = keySet(propertyKeywords_);

var nonStandardPropertyKeywords_ = [
    "scrollbar-arrow-color", "scrollbar-base-color", "scrollbar-dark-shadow-color",
    "scrollbar-face-color", "scrollbar-highlight-color", "scrollbar-shadow-color",
    "scrollbar-3d-light-color", "scrollbar-track-color", "shape-inside",
    "searchfield-cancel-button", "searchfield-decoration", "searchfield-results-button",
    "searchfield-results-decoration", "zoom"
  ], nonStandardPropertyKeywords = keySet(nonStandardPropertyKeywords_);

var fontProperties_ = [
    "font-family", "src", "unicode-range", "font-variant", "font-feature-settings",
    "font-stretch", "font-weight", "font-style"
  ], fontProperties = keySet(fontProperties_);

var counterDescriptors_ = [
    "additive-symbols", "fallback", "negative", "pad", "prefix", "range",
    "speak-as", "suffix", "symbols", "system"
  ], counterDescriptors = keySet(counterDescriptors_);

var colorKeywords_ = [
    "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige",
    "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown",
    "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", "cornflowerblue",
    "cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod",
    "darkgray", "darkgreen", "darkkhaki", "darkmagenta", "darkolivegreen",
    "darkorange", "darkorchid", "darkred", "darksalmon", "darkseagreen",
    "darkslateblue", "darkslategray", "darkturquoise", "darkviolet",
    "deeppink", "deepskyblue", "dimgray", "dodgerblue", "firebrick",
    "floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite",
    "gold", "goldenrod", "gray", "grey", "green", "greenyellow", "honeydew",
    "hotpink", "indianred", "indigo", "ivory", "khaki", "lavender",
    "lavenderblush", "lawngreen", "lemonchiffon", "lightblue", "lightcoral",
    "lightcyan", "lightgoldenrodyellow", "lightgray", "lightgreen", "lightpink",
    "lightsalmon", "lightseagreen", "lightskyblue", "lightslategray",
    "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta",
    "maroon", "mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple",
    "mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise",
    "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin",
    "navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange", "orangered",
    "orchid", "palegoldenrod", "palegreen", "paleturquoise", "palevioletred",
    "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue",
    "purple", "rebeccapurple", "red", "rosybrown", "royalblue", "saddlebrown",
    "salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver", "skyblue",
    "slateblue", "slategray", "snow", "springgreen", "steelblue", "tan",
    "teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white",
    "whitesmoke", "yellow", "yellowgreen"
  ], colorKeywords = keySet(colorKeywords_);

var valueKeywords_ = [
    "above", "absolute", "activeborder", "additive", "activecaption", "afar",
    "after-white-space", "ahead", "alias", "all", "all-scroll", "alphabetic", "alternate",
    "always", "amharic", "amharic-abegede", "antialiased", "appworkspace",
    "arabic-indic", "armenian", "asterisks", "attr", "auto", "auto-flow", "avoid", "avoid-column", "avoid-page",
    "avoid-region", "background", "backwards", "baseline", "below", "bidi-override", "binary",
    "bengali", "blink", "block", "block-axis", "bold", "bolder", "border", "border-box",
    "both", "bottom", "break", "break-all", "break-word", "bullets", "button", "button-bevel",
    "buttonface", "buttonhighlight", "buttonshadow", "buttontext", "calc", "cambodian",
    "capitalize", "caps-lock-indicator", "caption", "captiontext", "caret",
    "cell", "center", "checkbox", "circle", "cjk-decimal", "cjk-earthly-branch",
    "cjk-heavenly-stem", "cjk-ideographic", "clear", "clip", "close-quote",
    "col-resize", "collapse", "color", "color-burn", "color-dodge", "column", "column-reverse",
    "compact", "condensed", "contain", "content", "contents",
    "content-box", "context-menu", "continuous", "copy", "counter", "counters", "cover", "crop",
    "cross", "crosshair", "currentcolor", "cursive", "cyclic", "darken", "dashed", "decimal",
    "decimal-leading-zero", "default", "default-button", "dense", "destination-atop",
    "destination-in", "destination-out", "destination-over", "devanagari", "difference",
    "disc", "discard", "disclosure-closed", "disclosure-open", "document",
    "dot-dash", "dot-dot-dash",
    "dotted", "double", "down", "e-resize", "ease", "ease-in", "ease-in-out", "ease-out",
    "element", "ellipse", "ellipsis", "embed", "end", "ethiopic", "ethiopic-abegede",
    "ethiopic-abegede-am-et", "ethiopic-abegede-gez", "ethiopic-abegede-ti-er",
    "ethiopic-abegede-ti-et", "ethiopic-halehame-aa-er",
    "ethiopic-halehame-aa-et", "ethiopic-halehame-am-et",
    "ethiopic-halehame-gez", "ethiopic-halehame-om-et",
    "ethiopic-halehame-sid-et", "ethiopic-halehame-so-et",
    "ethiopic-halehame-ti-er", "ethiopic-halehame-ti-et", "ethiopic-halehame-tig",
    "ethiopic-numeric", "ew-resize", "exclusion", "expanded", "extends", "extra-condensed",
    "extra-expanded", "fantasy", "fast", "fill", "fixed", "flat", "flex", "flex-end", "flex-start", "footnotes",
    "forwards", "from", "geometricPrecision", "georgian", "graytext", "grid", "groove",
    "gujarati", "gurmukhi", "hand", "hangul", "hangul-consonant", "hard-light", "hebrew",
    "help", "hidden", "hide", "higher", "highlight", "highlighttext",
    "hiragana", "hiragana-iroha", "horizontal", "hsl", "hsla", "hue", "icon", "ignore",
    "inactiveborder", "inactivecaption", "inactivecaptiontext", "infinite",
    "infobackground", "infotext", "inherit", "initial", "inline", "inline-axis",
    "inline-block", "inline-flex", "inline-grid", "inline-table", "inset", "inside", "intrinsic", "invert",
    "italic", "japanese-formal", "japanese-informal", "justify", "kannada",
    "katakana", "katakana-iroha", "keep-all", "khmer",
    "korean-hangul-formal", "korean-hanja-formal", "korean-hanja-informal",
    "landscape", "lao", "large", "larger", "left", "level", "lighter", "lighten",
    "line-through", "linear", "linear-gradient", "lines", "list-item", "listbox", "listitem",
    "local", "logical", "loud", "lower", "lower-alpha", "lower-armenian",
    "lower-greek", "lower-hexadecimal", "lower-latin", "lower-norwegian",
    "lower-roman", "lowercase", "ltr", "luminosity", "malayalam", "match", "matrix", "matrix3d",
    "media-controls-background", "media-current-time-display",
    "media-fullscreen-button", "media-mute-button", "media-play-button",
    "media-return-to-realtime-button", "media-rewind-button",
    "media-seek-back-button", "media-seek-forward-button", "media-slider",
    "media-sliderthumb", "media-time-remaining-display", "media-volume-slider",
    "media-volume-slider-container", "media-volume-sliderthumb", "medium",
    "menu", "menulist", "menulist-button", "menulist-text",
    "menulist-textfield", "menutext", "message-box", "middle", "min-intrinsic",
    "mix", "mongolian", "monospace", "move", "multiple", "multiply", "myanmar", "n-resize",
    "narrower", "ne-resize", "nesw-resize", "no-close-quote", "no-drop",
    "no-open-quote", "no-repeat", "none", "normal", "not-allowed", "nowrap",
    "ns-resize", "numbers", "numeric", "nw-resize", "nwse-resize", "oblique", "octal", "opacity", "open-quote",
    "optimizeLegibility", "optimizeSpeed", "oriya", "oromo", "outset",
    "outside", "outside-shape", "overlay", "overline", "padding", "padding-box",
    "painted", "page", "paused", "persian", "perspective", "plus-darker", "plus-lighter",
    "pointer", "polygon", "portrait", "pre", "pre-line", "pre-wrap", "preserve-3d",
    "progress", "push-button", "radial-gradient", "radio", "read-only",
    "read-write", "read-write-plaintext-only", "rectangle", "region",
    "relative", "repeat", "repeating-linear-gradient",
    "repeating-radial-gradient", "repeat-x", "repeat-y", "reset", "reverse",
    "rgb", "rgba", "ridge", "right", "rotate", "rotate3d", "rotateX", "rotateY",
    "rotateZ", "round", "row", "row-resize", "row-reverse", "rtl", "run-in", "running",
    "s-resize", "sans-serif", "saturation", "scale", "scale3d", "scaleX", "scaleY", "scaleZ", "screen",
    "scroll", "scrollbar", "scroll-position", "se-resize", "searchfield",
    "searchfield-cancel-button", "searchfield-decoration",
    "searchfield-results-button", "searchfield-results-decoration", "self-start", "self-end",
    "semi-condensed", "semi-expanded", "separate", "serif", "show", "sidama",
    "simp-chinese-formal", "simp-chinese-informal", "single",
    "skew", "skewX", "skewY", "skip-white-space", "slide", "slider-horizontal",
    "slider-vertical", "sliderthumb-horizontal", "sliderthumb-vertical", "slow",
    "small", "small-caps", "small-caption", "smaller", "soft-light", "solid", "somali",
    "source-atop", "source-in", "source-out", "source-over", "space", "space-around", "space-between", "space-evenly", "spell-out", "square",
    "square-button", "start", "static", "status-bar", "stretch", "stroke", "sub",
    "subpixel-antialiased", "super", "sw-resize", "symbolic", "symbols", "system-ui", "table",
    "table-caption", "table-cell", "table-column", "table-column-group",
    "table-footer-group", "table-header-group", "table-row", "table-row-group",
    "tamil",
    "telugu", "text", "text-bottom", "text-top", "textarea", "textfield", "thai",
    "thick", "thin", "threeddarkshadow", "threedface", "threedhighlight",
    "threedlightshadow", "threedshadow", "tibetan", "tigre", "tigrinya-er",
    "tigrinya-er-abegede", "tigrinya-et", "tigrinya-et-abegede", "to", "top",
    "trad-chinese-formal", "trad-chinese-informal", "transform",
    "translate", "translate3d", "translateX", "translateY", "translateZ",
    "transparent", "ultra-condensed", "ultra-expanded", "underline", "unset", "up",
    "upper-alpha", "upper-armenian", "upper-greek", "upper-hexadecimal",
    "upper-latin", "upper-norwegian", "upper-roman", "uppercase", "urdu", "url",
    "var", "vertical", "vertical-text", "visible", "visibleFill", "visiblePainted",
    "visibleStroke", "visual", "w-resize", "wait", "wave", "wider",
    "window", "windowframe", "windowtext", "words", "wrap", "wrap-reverse", "x-large", "x-small", "xor",
    "xx-large", "xx-small"
  ], valueKeywords = keySet(valueKeywords_);

var allWords = documentTypes_.concat(mediaTypes_).concat(mediaFeatures_).concat(mediaValueKeywords_)
    .concat(propertyKeywords_).concat(nonStandardPropertyKeywords_).concat(colorKeywords_)
    .concat(valueKeywords_);
  CodeMirror.registerHelper("hintWords", "css", allWords);

CodeMirror.defineMIME("text/css", {
    documentTypes: documentTypes,
    mediaTypes: mediaTypes,
    mediaFeatures: mediaFeatures,
    mediaValueKeywords: mediaValueKeywords,
    propertyKeywords: propertyKeywords,
    nonStandardPropertyKeywords: nonStandardPropertyKeywords,
    fontProperties: fontProperties,
    counterDescriptors: counterDescriptors,
    colorKeywords: colorKeywords,
    valueKeywords: valueKeywords,
    tokenHooks: {
      "/": function(stream, state) {
        if (!stream.eat("*")) return false;
        state.tokenize = tokenCComment;
        return tokenCComment(stream, state);
      }
    },
    name: "css"
  });

CodeMirror.defineMIME("text/x-scss", {
    mediaTypes: mediaTypes,
    mediaFeatures: mediaFeatures,
    mediaValueKeywords: mediaValueKeywords,
    propertyKeywords: propertyKeywords,
    nonStandardPropertyKeywords: nonStandardPropertyKeywords,
    colorKeywords: colorKeywords,
    valueKeywords: valueKeywords,
    fontProperties: fontProperties,
    allowNested: true,
    lineComment: "//",
    tokenHooks: {
      "/": function(stream, state) {
        if (stream.eat("/")) {
          stream.skipToEnd();
          return ["comment", "comment"];
        } else if (stream.eat("*")) {
          state.tokenize = tokenCComment;
          return tokenCComment(stream, state);
        } else {
          return ["operator", "operator"];
        }
      },
      ":": function(stream) {
        if (stream.match(/\s*\{/, false))
          return [null, null]
        return false;
      },
      "$": function(stream) {
        stream.match(/^[\w-]+/);
        if (stream.match(/^\s*:/, false))
          return ["variable-2", "variable-definition"];
        return ["variable-2", "variable"];
      },
      "#": function(stream) {
        if (!stream.eat("{")) return false;
        return [null, "interpolation"];
      }
    },
    name: "css",
    helperType: "scss"
  });

CodeMirror.defineMIME("text/x-less", {
    mediaTypes: mediaTypes,
    mediaFeatures: mediaFeatures,
    mediaValueKeywords: mediaValueKeywords,
    propertyKeywords: propertyKeywords,
    nonStandardPropertyKeywords: nonStandardPropertyKeywords,
    colorKeywords: colorKeywords,
    valueKeywords: valueKeywords,
    fontProperties: fontProperties,
    allowNested: true,
    lineComment: "//",
    tokenHooks: {
      "/": function(stream, state) {
        if (stream.eat("/")) {
          stream.skipToEnd();
          return ["comment", "comment"];
        } else if (stream.eat("*")) {
          state.tokenize = tokenCComment;
          return tokenCComment(stream, state);
        } else {
          return ["operator", "operator"];
        }
      },
      "@": function(stream) {
        if (stream.eat("{")) return [null, "interpolation"];
        if (stream.match(/^(charset|document|font-face|import|(-(moz|ms|o|webkit)-)?keyframes|media|namespace|page|supports)\b/i, false)) return false;
        stream.eatWhile(/[\w\\\-]/);
        if (stream.match(/^\s*:/, false))
          return ["variable-2", "variable-definition"];
        return ["variable-2", "variable"];
      },
      "&": function() {
        return ["atom", "atom"];
      }
    },
    name: "css",
    helperType: "less"
  });

CodeMirror.defineMIME("text/x-gss", {
    documentTypes: documentTypes,
    mediaTypes: mediaTypes,
    mediaFeatures: mediaFeatures,
    propertyKeywords: propertyKeywords,
    nonStandardPropertyKeywords: nonStandardPropertyKeywords,
    fontProperties: fontProperties,
    counterDescriptors: counterDescriptors,
    colorKeywords: colorKeywords,
    valueKeywords: valueKeywords,
    supportsAtComponent: true,
    tokenHooks: {
      "/": function(stream, state) {
        if (!stream.eat("*")) return false;
        state.tokenize = tokenCComment;
        return tokenCComment(stream, state);
      }
    },
    name: "css",
    helperType: "gss"
  });

});

/***/ }),
/* 791 */
/***/ (function(module, exports, __webpack_require__) {

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE

CodeMirror.defineMode("javascript", function(config, parserConfig) {
  var indentUnit = config.indentUnit;
  var statementIndent = parserConfig.statementIndent;
  var jsonldMode = parserConfig.jsonld;
  var jsonMode = parserConfig.json || jsonldMode;
  var isTS = parserConfig.typescript;
  var wordRE = parserConfig.wordCharacters || /[\w$\xa1-\uffff]/;

// Tokenizer

return {
      "if": kw("if"), "while": A, "with": A, "else": B, "do": B, "try": B, "finally": B,
      "return": D, "break": D, "continue": D, "new": kw("new"), "delete": C, "void": C, "throw": C,
      "debugger": kw("debugger"), "var": kw("var"), "const": kw("var"), "let": kw("var"),
      "function": kw("function"), "catch": kw("catch"),
      "for": kw("for"), "switch": kw("switch"), "case": kw("case"), "default": kw("default"),
      "in": operator, "typeof": operator, "instanceof": operator,
      "true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom,
      "this": kw("this"), "class": kw("class"), "super": kw("atom"),
      "yield": C, "export": kw("export"), "import": kw("import"), "extends": C,
      "await": C
    };
  }();

// Used as scratch variables to communicate multiple values without
  // consing up tons of objects.
  var type, content;
  function ret(tp, style, cont) {
    type = tp; content = cont;
    return style;
  }
  function tokenBase(stream, state) {
    var ch = stream.next();
    if (ch == '"' || ch == "'") {
      state.tokenize = tokenString(ch);
      return state.tokenize(stream, state);
    } else if (ch == "." && stream.match(/^\d+(?:[eE][+\-]?\d+)?/)) {
      return ret("number", "number");
    } else if (ch == "." && stream.match("..")) {
      return ret("spread", "meta");
    } else if (/[\[\]{},;\:\.]/.test(ch)) {
      return ret(ch);
    } else if (ch == "=" && stream.eat(">")) {
      return ret("=>", "operator");
    } else if (ch == "0" && stream.match(/^(?:x[\da-f]+|o[0-7]+|b[01]+)n?/i)) {
      return ret("number", "number");
    } else if (/\d/.test(ch)) {
      stream.match(/^\d*(?:n|(?:\.\d*)?(?:[eE][+\-]?\d+)?)?/);
      return ret("number", "number");
    } else if (ch == "/") {
      if (stream.eat("*")) {
        state.tokenize = tokenComment;
        return tokenComment(stream, state);
      } else if (stream.eat("/")) {
        stream.skipToEnd();
        return ret("comment", "comment");
      } else if (expressionAllowed(stream, state, 1)) {
        readRegexp(stream);
        stream.match(/^\b(([gimyus])(?![gimyus]*\2))+\b/);
        return ret("regexp", "string-2");
      } else {
        stream.eat("=");
        return ret("operator", "operator", stream.current());
      }
    } else if (ch == "`") {
      state.tokenize = tokenQuasi;
      return tokenQuasi(stream, state);
    } else if (ch == "#") {
      stream.skipToEnd();
      return ret("error", "error");
    } else if (isOperatorChar.test(ch)) {
      if (ch != ">" || !state.lexical || state.lexical.type != ">") {
        if (stream.eat("=")) {
          if (ch == "!" || ch == "=") stream.eat("=")
        } else if (/[<>*+\-]/.test(ch)) {
          stream.eat(ch)
          if (ch == ">") stream.eat(ch)
        }
      }
      return ret("operator", "operator", stream.current());
    } else if (wordRE.test(ch)) {
      stream.eatWhile(wordRE);
      var word = stream.current()
      if (state.lastType != ".") {
        if (keywords.propertyIsEnumerable(word)) {
          var kw = keywords[word]
          return ret(kw.type, kw.style, word)
        }
        if (word == "async" && stream.match(/^(\s|\/\*.*?\*\/)*[\[\(\w]/, false))
          return ret("async", "keyword", word)
      }
      return ret("variable", "variable", word)
    }
  }

var brackets = "([{}])";
  // This is a crude lookahead trick to try and notice that we're
  // parsing the argument patterns for a fat-arrow function before we
  // actually hit the arrow token. It only works if the arrow is on
  // the same line as the arguments and there's no strange noise
  // (comments) in between. Fallback is to only notice when we hit the
  // arrow, and not declare the arguments as locals for the arrow
  // body.
  function findFatArrow(stream, state) {
    if (state.fatArrowAt) state.fatArrowAt = null;
    var arrow = stream.string.indexOf("=>", stream.start);
    if (arrow < 0) return;

if (isTS) { // Try to skip TypeScript return type declarations after the arguments
      var m = /:\s*(?:\w+(?:<[^>]*>|\[\])?|\{[^}]*\})\s*$/.exec(stream.string.slice(stream.start, arrow))
      if (m) arrow = m.index
    }

// Parser

var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true, "this": true, "jsonld-keyword": true};

function JSLexical(indented, column, type, align, prev, info) {
    this.indented = indented;
    this.column = column;
    this.type = type;
    this.prev = prev;
    this.info = info;
    if (align != null) this.align = align;
  }

function inScope(state, varname) {
    for (var v = state.localVars; v; v = v.next)
      if (v.name == varname) return true;
    for (var cx = state.context; cx; cx = cx.prev) {
      for (var v = cx.vars; v; v = v.next)
        if (v.name == varname) return true;
    }
  }

function parseJS(state, style, type, content, stream) {
    var cc = state.cc;
    // Communicate our context to the combinators.
    // (Less wasteful than consing up a hundred closures on every call.)
    cx.state = state; cx.stream = stream; cx.marked = null, cx.cc = cc; cx.style = style;

if (!state.lexical.hasOwnProperty("align"))
      state.lexical.align = true;

while(true) {
      var combinator = cc.length ? cc.pop() : jsonMode ? expression : statement;
      if (combinator(type, content)) {
        while(cc.length && cc[cc.length - 1].lex)
          cc.pop()();
        if (cx.marked) return cx.marked;
        if (type == "variable" && inScope(state, content)) return "variable-2";
        return style;
      }
    }
  }

// Combinator utils

function isModifier(name) {
    return name == "public" || name == "private" || name == "protected" || name == "abstract" || name == "readonly"
  }

// Combinators

function Context(prev, vars, block) { this.prev = prev; this.vars = vars; this.block = block }
  function Var(name, next) { this.name = name; this.next = next }

function expect(wanted) {
    function exp(type) {
      if (type == wanted) return cont();
      else if (wanted == ";" || type == "}" || type == ")" || type == "]") return pass();
      else return cont(exp);
    };
    return exp;
  }

function isContinuedStatement(state, textAfter) {
    return state.lastType == "operator" || state.lastType == "," ||
      isOperatorChar.test(textAfter.charAt(0)) ||
      /[,.]/.test(textAfter.charAt(0));
  }

function expressionAllowed(stream, state, backUp) {
    return state.tokenize == tokenBase &&
      /^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\[{}\(,;:]|=>)$/.test(state.lastType) ||
      (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))
  }

// Interface

return {
    startState: function(basecolumn) {
      var state = {
        tokenize: tokenBase,
        lastType: "sof",
        cc: [],
        lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
        localVars: parserConfig.localVars,
        context: parserConfig.localVars && new Context(null, null, false),
        indented: basecolumn || 0
      };
      if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
        state.globalVars = parserConfig.globalVars;
      return state;
    },

token: function(stream, state) {
      if (stream.sol()) {
        if (!state.lexical.hasOwnProperty("align"))
          state.lexical.align = false;
        state.indented = stream.indentation();
        findFatArrow(stream, state);
      }
      if (state.tokenize != tokenComment && stream.eatSpace()) return null;
      var style = state.tokenize(stream, state);
      if (type == "comment") return style;
      state.lastType = type == "operator" && (content == "++" || content == "--") ? "incdec" : type;
      return parseJS(state, style, type, content, stream);
    },

indent: function(state, textAfter) {
      if (state.tokenize == tokenComment) return CodeMirror.Pass;
      if (state.tokenize != tokenBase) return 0;
      var firstChar = textAfter && textAfter.charAt(0), lexical = state.lexical, top
      // Kludge to prevent 'maybelse' from blocking lexical scope pops
      if (!/^\s*else\b/.test(textAfter)) for (var i = state.cc.length - 1; i >= 0; --i) {
        var c = state.cc[i];
        if (c == poplex) lexical = lexical.prev;
        else if (c != maybeelse) break;
      }
      while ((lexical.type == "stat" || lexical.type == "form") &&
             (firstChar == "}" || ((top = state.cc[state.cc.length - 1]) &&
                                   (top == maybeoperatorComma || top == maybeoperatorNoComma) &&
                                   !/^[,\.=+\-*:?[\(]/.test(textAfter))))
        lexical = lexical.prev;
      if (statementIndent && lexical.type == ")" && lexical.prev.type == "stat")
        lexical = lexical.prev;
      var type = lexical.type, closing = firstChar == type;

if (type == "vardef") return lexical.indented + (state.lastType == "operator" || state.lastType == "," ? lexical.info.length + 1 : 0);
      else if (type == "form" && firstChar == "{") return lexical.indented;
      else if (type == "form") return lexical.indented + indentUnit;
      else if (type == "stat")
        return lexical.indented + (isContinuedStatement(state, textAfter) ? statementIndent || indentUnit : 0);
      else if (lexical.info == "switch" && !closing && parserConfig.doubleIndentSwitch != false)
        return lexical.indented + (/^(?:case|default)\b/.test(textAfter) ? indentUnit : 2 * indentUnit);
      else if (lexical.align) return lexical.column + (closing ? 0 : 1);
      else return lexical.indented + (closing ? 0 : indentUnit);
    },

electricInput: /^\s*(?:case .*?:|default:|\{|\})$/,
    blockCommentStart: jsonMode ? null : "/*",
    blockCommentEnd: jsonMode ? null : "*/",
    blockCommentContinue: jsonMode ? null : " * ",
    lineComment: jsonMode ? null : "//",
    fold: "brace",
    closeBrackets: "()[]{}''\"\"``",

helperType: jsonMode ? "json" : "javascript",
    jsonldMode: jsonldMode,
    jsonMode: jsonMode,

expressionAllowed: expressionAllowed,

skipExpression: function(state) {
      var top = state.cc[state.cc.length - 1]
      if (top == expression || top == expressionNoComma) state.cc.pop()
    }
  };
});

CodeMirror.registerHelper("wordChars", "javascript", /[\w$]/);

CodeMirror.defineMIME("text/javascript", "javascript");
CodeMirror.defineMIME("text/ecmascript", "javascript");
CodeMirror.defineMIME("application/javascript", "javascript");
CodeMirror.defineMIME("application/x-javascript", "javascript");
CodeMirror.defineMIME("application/ecmascript", "javascript");
CodeMirror.defineMIME("application/json", {name: "javascript", json: true});
CodeMirror.defineMIME("application/x-json", {name: "javascript", json: true});
CodeMirror.defineMIME("application/ld+json", {name: "javascript", jsonld: true});
CodeMirror.defineMIME("text/typescript", { name: "javascript", typescript: true });
CodeMirror.defineMIME("application/typescript", { name: "javascript", typescript: true });

});

/***/ }),
/* 792 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(397);
__webpack_require__(823);
module.exports = __webpack_require__(34).Array.from;

/***/ }),
/* 793 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(825);
module.exports = __webpack_require__(34).Object.assign;

/***/ }),
/* 794 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(826);
var $Object = __webpack_require__(34).Object;
module.exports = function create(P, D) {
  return $Object.create(P, D);
};

/***/ }),
/* 795 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(827);
var $Object = __webpack_require__(34).Object;
module.exports = function defineProperty(it, key, desc) {
  return $Object.defineProperty(it, key, desc);
};

/***/ }),
/* 796 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(828);
var $Object = __webpack_require__(34).Object;
module.exports = function getOwnPropertyDescriptor(it, key) {
  return $Object.getOwnPropertyDescriptor(it, key);
};

/***/ }),
/* 797 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(829);
module.exports = __webpack_require__(34).Object.getPrototypeOf;

/***/ }),
/* 798 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(830);
module.exports = __webpack_require__(34).Object.keys;

/***/ }),
/* 799 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(831);
module.exports = __webpack_require__(34).Object.setPrototypeOf;

/***/ }),
/* 800 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(833);
__webpack_require__(832);
__webpack_require__(834);
__webpack_require__(835);
module.exports = __webpack_require__(34).Symbol;

/***/ }),
/* 801 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(397);
__webpack_require__(836);
module.exports = __webpack_require__(259).f('iterator');

/***/ }),
/* 802 */
/***/ (function(module, exports) {

module.exports = function (it) {
  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
  return it;
};

/***/ }),
/* 803 */
/***/ (function(module, exports) {

module.exports = function () { /* empty */ };

/***/ }),
/* 804 */
/***/ (function(module, exports, __webpack_require__) {

// false -> Array#indexOf
// true  -> Array#includes
var toIObject = __webpack_require__(82);
var toLength = __webpack_require__(396);
var toAbsoluteIndex = __webpack_require__(821);
module.exports = function (IS_INCLUDES) {
  return function ($this, el, fromIndex) {
    var O = toIObject($this);
    var length = toLength(O.length);
    var index = toAbsoluteIndex(fromIndex, length);
    var value;
    // Array#includes uses SameValueZero equality algorithm
    // eslint-disable-next-line no-self-compare
    if (IS_INCLUDES && el != el) while (length > index) {
      value = O[index++];
      // eslint-disable-next-line no-self-compare
      if (value != value) return true;
    // Array#indexOf ignores holes, Array#includes - not
    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
      if (O[index] === el) return IS_INCLUDES || index || 0;
    } return !IS_INCLUDES && -1;
  };
};

/***/ }),
/* 805 */
/***/ (function(module, exports, __webpack_require__) {

// getting tag from 19.1.3.6 Object.prototype.toString()
var cof = __webpack_require__(245);
var TAG = __webpack_require__(55)('toStringTag');
// ES3 wrong here
var ARG = cof(function () { return arguments; }()) == 'Arguments';

// fallback for IE11 Script Access Denied error
var tryGet = function (it, key) {
  try {
    return it[key];
  } catch (e) { /* empty */ }
};

module.exports = function (it) {
  var O, T, B;
  return it === undefined ? 'Undefined' : it === null ? 'Null'
    // @@toStringTag case
    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
    // builtinTag case
    : ARG ? cof(O)
    // ES3 arguments fallback
    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
};

/***/ }),
/* 806 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $defineProperty = __webpack_require__(71);
var createDesc = __webpack_require__(129);

module.exports = function (object, index, value) {
  if (index in object) $defineProperty.f(object, index, createDesc(0, value));
  else object[index] = value;
};

/***/ }),
/* 807 */
/***/ (function(module, exports, __webpack_require__) {

// all enumerable object keys, includes symbols
var getKeys = __webpack_require__(128);
var gOPS = __webpack_require__(251);
var pIE = __webpack_require__(163);
module.exports = function (it) {
  var result = getKeys(it);
  var getSymbols = gOPS.f;
  if (getSymbols) {
    var symbols = getSymbols(it);
    var isEnum = pIE.f;
    var i = 0;
    var key;
    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);
  } return result;
};

/***/ }),
/* 808 */
/***/ (function(module, exports, __webpack_require__) {

var document = __webpack_require__(70).document;
module.exports = document && document.documentElement;

/***/ }),
/* 809 */
/***/ (function(module, exports, __webpack_require__) {

// check on default Array iterator
var Iterators = __webpack_require__(127);
var ITERATOR = __webpack_require__(55)('iterator');
var ArrayProto = Array.prototype;

module.exports = function (it) {
  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
};

/***/ }),
/* 810 */
/***/ (function(module, exports, __webpack_require__) {

// 7.2.2 IsArray(argument)
var cof = __webpack_require__(245);
module.exports = Array.isArray || function isArray(arg) {
  return cof(arg) == 'Array';
};

/***/ }),
/* 811 */
/***/ (function(module, exports, __webpack_require__) {

// call something on iterator step with safe closing on error
var anObject = __webpack_require__(100);
module.exports = function (iterator, fn, value, entries) {
  try {
    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
  // 7.4.6 IteratorClose(iterator, completion)
  } catch (e) {
    var ret = iterator['return'];
    if (ret !== undefined) anObject(ret.call(iterator));
    throw e;
  }
};

/***/ }),
/* 812 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var create = __webpack_require__(249);
var descriptor = __webpack_require__(129);
var setToStringTag = __webpack_require__(253);
var IteratorPrototype = {};

// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
__webpack_require__(102)(IteratorPrototype, __webpack_require__(55)('iterator'), function () { return this; });

module.exports = function (Constructor, NAME, next) {
  Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
  setToStringTag(Constructor, NAME + ' Iterator');
};

/***/ }),
/* 813 */
/***/ (function(module, exports, __webpack_require__) {

var ITERATOR = __webpack_require__(55)('iterator');
var SAFE_CLOSING = false;

try {
  var riter = [7][ITERATOR]();
  riter['return'] = function () { SAFE_CLOSING = true; };
  // eslint-disable-next-line no-throw-literal
  Array.from(riter, function () { throw 2; });
} catch (e) { /* empty */ }

module.exports = function (exec, skipClosing) {
  if (!skipClosing && !SAFE_CLOSING) return false;
  var safe = false;
  try {
    var arr = [7];
    var iter = arr[ITERATOR]();
    iter.next = function () { return { done: safe = true }; };
    arr[ITERATOR] = function () { return iter; };
    exec(arr);
  } catch (e) { /* empty */ }
  return safe;
};

/***/ }),
/* 814 */
/***/ (function(module, exports) {

module.exports = function (done, value) {
  return { value: value, done: !!done };
};

/***/ }),
/* 815 */
/***/ (function(module, exports, __webpack_require__) {

/***/ }),
/* 816 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 19.1.2.1 Object.assign(target, source, ...)
var DESCRIPTORS = __webpack_require__(68);
var getKeys = __webpack_require__(128);
var gOPS = __webpack_require__(251);
var pIE = __webpack_require__(163);
var toObject = __webpack_require__(104);
var IObject = __webpack_require__(390);
var $assign = Object.assign;

// should work with symbols and should have deterministic property order (V8 bug)
module.exports = !$assign || __webpack_require__(101)(function () {
  var A = {};
  var B = {};
  // eslint-disable-next-line no-undef
  var S = Symbol();
  var K = 'abcdefghijklmnopqrst';
  A[S] = 7;
  K.split('').forEach(function (k) { B[k] = k; });
  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
  var T = toObject(target);
  var aLen = arguments.length;
  var index = 1;
  var getSymbols = gOPS.f;
  var isEnum = pIE.f;
  while (aLen > index) {
    var S = IObject(arguments[index++]);
    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
    var length = keys.length;
    var j = 0;
    var key;
    while (length > j) {
      key = keys[j++];
      if (!DESCRIPTORS || isEnum.call(S, key)) T[key] = S[key];
    }
  } return T;
} : $assign;

/***/ }),
/* 817 */
/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(71);
var anObject = __webpack_require__(100);
var getKeys = __webpack_require__(128);

module.exports = __webpack_require__(68) ? Object.defineProperties : function defineProperties(O, Properties) {
  anObject(O);
  var keys = getKeys(Properties);
  var length = keys.length;
  var i = 0;
  var P;
  while (length > i) dP.f(O, P = keys[i++], Properties[P]);
  return O;
};

/***/ }),
/* 818 */
/***/ (function(module, exports, __webpack_require__) {

// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
var toIObject = __webpack_require__(82);
var gOPN = __webpack_require__(392).f;
var toString = {}.toString;

var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
  ? Object.getOwnPropertyNames(window) : [];

var getWindowNames = function (it) {
  try {
    return gOPN(it);
  } catch (e) {
    return windowNames.slice();
  }
};

module.exports.f = function getOwnPropertyNames(it) {
  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
};

/***/ }),
/* 819 */
/***/ (function(module, exports, __webpack_require__) {

// Works with __proto__ only. Old v8 can't work with null proto objects.
/* eslint-disable no-proto */
var isObject = __webpack_require__(103);
var anObject = __webpack_require__(100);
var check = function (O, proto) {
  anObject(O);
  if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!");
};
module.exports = {
  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
    function (test, buggy, set) {
      try {
        set = __webpack_require__(246)(Function.call, __webpack_require__(250).f(Object.prototype, '__proto__').set, 2);
        set(test, []);
        buggy = !(test instanceof Array);
      } catch (e) { buggy = true; }
      return function setPrototypeOf(O, proto) {
        check(O, proto);
        if (buggy) O.__proto__ = proto;
        else set(O, proto);
        return O;
      };
    }({}, false) : undefined),
  check: check
};

/***/ }),
/* 820 */
/***/ (function(module, exports, __webpack_require__) {

var toInteger = __webpack_require__(256);
var defined = __webpack_require__(247);
// true  -> String#at
// false -> String#codePointAt
module.exports = function (TO_STRING) {
  return function (that, pos) {
    var s = String(defined(that));
    var i = toInteger(pos);
    var l = s.length;
    var a, b;
    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
    a = s.charCodeAt(i);
    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
      ? TO_STRING ? s.charAt(i) : a
      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
  };
};

/***/ }),
/* 821 */
/***/ (function(module, exports, __webpack_require__) {

var toInteger = __webpack_require__(256);
var max = Math.max;
var min = Math.min;
module.exports = function (index, length) {
  index = toInteger(index);
  return index < 0 ? max(index + length, 0) : min(index, length);
};

/***/ }),
/* 822 */
/***/ (function(module, exports, __webpack_require__) {

var classof = __webpack_require__(805);
var ITERATOR = __webpack_require__(55)('iterator');
var Iterators = __webpack_require__(127);
module.exports = __webpack_require__(34).getIteratorMethod = function (it) {
  if (it != undefined) return it[ITERATOR]
    || it['@@iterator']
    || Iterators[classof(it)];
};

/***/ }),
/* 823 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var ctx = __webpack_require__(246);
var $export = __webpack_require__(69);
var toObject = __webpack_require__(104);
var call = __webpack_require__(811);
var isArrayIter = __webpack_require__(809);
var toLength = __webpack_require__(396);
var createProperty = __webpack_require__(806);
var getIterFn = __webpack_require__(822);

$export($export.S + $export.F * !__webpack_require__(813)(function (iter) { Array.from(iter); }), 'Array', {
  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
  from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
    var O = toObject(arrayLike);
    var C = typeof this == 'function' ? this : Array;
    var aLen = arguments.length;
    var mapfn = aLen > 1 ? arguments[1] : undefined;
    var mapping = mapfn !== undefined;
    var index = 0;
    var iterFn = getIterFn(O);
    var length, result, step, iterator;
    if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
    // if object isn't iterable or it's array with default iterator - use simple case
    if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {
      for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {
        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
      }
    } else {
      length = toLength(O.length);
      for (result = new C(length); length > index; index++) {
        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
      }
    }
    result.length = index;
    return result;
  }
});

/***/ }),
/* 824 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var addToUnscopables = __webpack_require__(803);
var step = __webpack_require__(814);
var Iterators = __webpack_require__(127);
var toIObject = __webpack_require__(82);

// 22.1.3.4 Array.prototype.entries()
// 22.1.3.13 Array.prototype.keys()
// 22.1.3.29 Array.prototype.values()
// 22.1.3.30 Array.prototype[@@iterator]()
module.exports = __webpack_require__(391)(Array, 'Array', function (iterated, kind) {
  this._t = toIObject(iterated); // target
  this._i = 0;                   // next index
  this._k = kind;                // kind
// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
}, function () {
  var O = this._t;
  var kind = this._k;
  var index = this._i++;
  if (!O || index >= O.length) {
    this._t = undefined;
    return step(1);
  }
  if (kind == 'keys') return step(0, index);
  if (kind == 'values') return step(0, O[index]);
  return step(0, [index, O[index]]);
}, 'values');

// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
Iterators.Arguments = Iterators.Array;

addToUnscopables('keys');
addToUnscopables('values');
addToUnscopables('entries');

/***/ }),
/* 825 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.3.1 Object.assign(target, source)
var $export = __webpack_require__(69);

$export($export.S + $export.F, 'Object', { assign: __webpack_require__(816) });

/***/ }),
/* 826 */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(69);
// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
$export($export.S, 'Object', { create: __webpack_require__(249) });

/***/ }),
/* 827 */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(69);
// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
$export($export.S + $export.F * !__webpack_require__(68), 'Object', { defineProperty: __webpack_require__(71).f });

/***/ }),
/* 828 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
var toIObject = __webpack_require__(82);
var $getOwnPropertyDescriptor = __webpack_require__(250).f;

__webpack_require__(252)('getOwnPropertyDescriptor', function () {
  return function getOwnPropertyDescriptor(it, key) {
    return $getOwnPropertyDescriptor(toIObject(it), key);
  };
});

/***/ }),
/* 829 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.9 Object.getPrototypeOf(O)
var toObject = __webpack_require__(104);
var $getPrototypeOf = __webpack_require__(393);

__webpack_require__(252)('getPrototypeOf', function () {
  return function getPrototypeOf(it) {
    return $getPrototypeOf(toObject(it));
  };
});

/***/ }),
/* 830 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.14 Object.keys(O)
var toObject = __webpack_require__(104);
var $keys = __webpack_require__(128);

__webpack_require__(252)('keys', function () {
  return function keys(it) {
    return $keys(toObject(it));
  };
});

/***/ }),
/* 831 */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.3.19 Object.setPrototypeOf(O, proto)
var $export = __webpack_require__(69);
$export($export.S, 'Object', { setPrototypeOf: __webpack_require__(819).set });

/***/ }),
/* 832 */
/***/ (function(module, exports) {

/***/ }),
/* 833 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// ECMAScript 6 symbols shim
var global = __webpack_require__(70);
var has = __webpack_require__(81);
var DESCRIPTORS = __webpack_require__(68);
var $export = __webpack_require__(69);
var redefine = __webpack_require__(395);
var META = __webpack_require__(815).KEY;
var $fails = __webpack_require__(101);
var shared = __webpack_require__(255);
var setToStringTag = __webpack_require__(253);
var uid = __webpack_require__(164);
var wks = __webpack_require__(55);
var wksExt = __webpack_require__(259);
var wksDefine = __webpack_require__(258);
var enumKeys = __webpack_require__(807);
var isArray = __webpack_require__(810);
var anObject = __webpack_require__(100);
var isObject = __webpack_require__(103);
var toObject = __webpack_require__(104);
var toIObject = __webpack_require__(82);
var toPrimitive = __webpack_require__(257);
var createDesc = __webpack_require__(129);
var _create = __webpack_require__(249);
var gOPNExt = __webpack_require__(818);
var $GOPD = __webpack_require__(250);
var $GOPS = __webpack_require__(251);
var $DP = __webpack_require__(71);
var $keys = __webpack_require__(128);
var gOPD = $GOPD.f;
var dP = $DP.f;
var gOPN = gOPNExt.f;
var $Symbol = global.Symbol;
var $JSON = global.JSON;
var _stringify = $JSON && $JSON.stringify;
var PROTOTYPE = 'prototype';
var HIDDEN = wks('_hidden');
var TO_PRIMITIVE = wks('toPrimitive');
var isEnum = {}.propertyIsEnumerable;
var SymbolRegistry = shared('symbol-registry');
var AllSymbols = shared('symbols');
var OPSymbols = shared('op-symbols');
var ObjectProto = Object[PROTOTYPE];
var USE_NATIVE = typeof $Symbol == 'function' && !!$GOPS.f;
var QObject = global.QObject;
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;

// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
var setSymbolDesc = DESCRIPTORS && $fails(function () {
  return _create(dP({}, 'a', {
    get: function () { return dP(this, 'a', { value: 7 }).a; }
  })).a != 7;
}) ? function (it, key, D) {
  var protoDesc = gOPD(ObjectProto, key);
  if (protoDesc) delete ObjectProto[key];
  dP(it, key, D);
  if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);
} : dP;

var wrap = function (tag) {
  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
  sym._k = tag;
  return sym;
};

var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {
  return typeof it == 'symbol';
} : function (it) {
  return it instanceof $Symbol;
};

// 19.4.1.1 Symbol([description])
if (!USE_NATIVE) {
  $Symbol = function Symbol() {
    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
    var $set = function (value) {
      if (this === ObjectProto) $set.call(OPSymbols, value);
      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
      setSymbolDesc(this, tag, createDesc(1, value));
    };
    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });
    return wrap(tag);
  };
  redefine($Symbol[PROTOTYPE], 'toString', function toString() {
    return this._k;
  });

$GOPD.f = $getOwnPropertyDescriptor;
  $DP.f = $defineProperty;
  __webpack_require__(392).f = gOPNExt.f = $getOwnPropertyNames;
  __webpack_require__(163).f = $propertyIsEnumerable;
  $GOPS.f = $getOwnPropertySymbols;

if (DESCRIPTORS && !__webpack_require__(162)) {
    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
  }

wksExt.f = function (name) {
    return wrap(wks(name));
  };
}

$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });

for (var es6Symbols = (
  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);

for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);

$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
  // 19.4.2.1 Symbol.for(key)
  'for': function (key) {
    return has(SymbolRegistry, key += '')
      ? SymbolRegistry[key]
      : SymbolRegistry[key] = $Symbol(key);
  },
  // 19.4.2.5 Symbol.keyFor(sym)
  keyFor: function keyFor(sym) {
    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;
  },
  useSetter: function () { setter = true; },
  useSimple: function () { setter = false; }
});

$export($export.S + $export.F * !USE_NATIVE, 'Object', {
  // 19.1.2.2 Object.create(O [, Properties])
  create: $create,
  // 19.1.2.4 Object.defineProperty(O, P, Attributes)
  defineProperty: $defineProperty,
  // 19.1.2.3 Object.defineProperties(O, Properties)
  defineProperties: $defineProperties,
  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
  // 19.1.2.7 Object.getOwnPropertyNames(O)
  getOwnPropertyNames: $getOwnPropertyNames,
  // 19.1.2.8 Object.getOwnPropertySymbols(O)
  getOwnPropertySymbols: $getOwnPropertySymbols
});

// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
// https://bugs.chromium.org/p/v8/issues/detail?id=3443
var FAILS_ON_PRIMITIVES = $fails(function () { $GOPS.f(1); });

$export($export.S + $export.F * FAILS_ON_PRIMITIVES, 'Object', {
  getOwnPropertySymbols: function getOwnPropertySymbols(it) {
    return $GOPS.f(toObject(it));
  }
});

// 24.3.2 JSON.stringify(value [, replacer [, space]])
$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {
  var S = $Symbol();
  // MS Edge converts symbol values to JSON as {}
  // WebKit converts symbol values to JSON as null
  // V8 throws on boxed symbols
  return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';
})), 'JSON', {
  stringify: function stringify(it) {
    var args = [it];
    var i = 1;
    var replacer, $replacer;
    while (arguments.length > i) args.push(arguments[i++]);
    $replacer = replacer = args[1];
    if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
    if (!isArray(replacer)) replacer = function (key, value) {
      if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
      if (!isSymbol(value)) return value;
    };
    args[1] = replacer;
    return _stringify.apply($JSON, args);
  }
});

// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
$Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(102)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
// 19.4.3.5 Symbol.prototype[@@toStringTag]
setToStringTag($Symbol, 'Symbol');
// 20.2.1.9 Math[@@toStringTag]
setToStringTag(Math, 'Math', true);
// 24.3.3 JSON[@@toStringTag]
setToStringTag(global.JSON, 'JSON', true);

/***/ }),
/* 834 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(258)('asyncIterator');

/***/ }),
/* 835 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(258)('observable');

/***/ }),
/* 836 */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(824);
var global = __webpack_require__(70);
var hide = __webpack_require__(102);
var Iterators = __webpack_require__(127);
var TO_STRING_TAG = __webpack_require__(55)('toStringTag');

var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
  'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
  'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
  'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
  'TextTrackList,TouchList').split(',');

for (var i = 0; i < DOMIterables.length; i++) {
  var NAME = DOMIterables[i];
  var Collection = global[NAME];
  var proto = Collection && Collection.prototype;
  if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
  Iterators[NAME] = Iterators.Array;
}

/***/ }),
/* 837 */
/***/ (function(module, exports, __webpack_require__) {

var _assign = __webpack_require__(24);

// -- Inlined from fbjs --

var emptyObject = {};

if (process.env.NODE_ENV !== 'production') {
  Object.freeze(emptyObject);
}

var validateFormat = function validateFormat(format) {};

function _invariant(condition, format, a, b, c, d, e, f) {
  validateFormat(format);

error.framesToPop = 1; // we don't care about invariant's own frame
    throw error;
  }
}

var warning = function(){};

warning = function warning(condition, format) {
    if (format === undefined) {
      throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
    }

if (format.indexOf('Failed Composite propType: ') === 0) {
      return; // Ignore CompositeComponent proptype check.
    }

if (!condition) {
      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
        args[_key2 - 2] = arguments[_key2];
      }

printWarning.apply(undefined, [format].concat(args));
    }
  };
}

// /-- Inlined from fbjs --

var MIXINS_KEY = 'mixins';

// Helper function to allow the creation of anonymous functions which do not
// have .name set to the name of the variable being assigned to.
function identity(fn) {
  return fn;
}

var ReactPropTypeLocationNames;
if (process.env.NODE_ENV !== 'production') {
  ReactPropTypeLocationNames = {
    prop: 'prop',
    context: 'context',
    childContext: 'child context'
  };
} else {
  ReactPropTypeLocationNames = {};
}

function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {
  /**
   * Policies that describe methods in `ReactClassInterface`.
   */

var injectedMixins = [];

/**
   * Composite components are higher-level components that compose other composite
   * or host components.
   *
   * To create a new type of `ReactClass`, pass a specification of
   * your new class to `React.createClass`. The only requirement of your class
   * specification is that you implement a `render` method.
   *
   *   var MyComponent = React.createClass({
   *     render: function() {
   *       return <div>Hello World</div>;
   *     }
   *   });
   *
   * The class specification supports a specific protocol of methods that have
   * special meaning (e.g. `render`). See `ReactClassInterface` for
   * more the comprehensive protocol. Any other properties and methods in the
   * class specification will be available on the prototype.
   *
   * @interface ReactClassInterface
   * @internal
   */
  var ReactClassInterface = {
    /**
     * An array of Mixin objects to include when defining your component.
     *
     * @type {array}
     * @optional
     */
    mixins: 'DEFINE_MANY',

/**
     * An object containing properties and methods that should be defined on
     * the component's constructor instead of its prototype (static methods).
     *
     * @type {object}
     * @optional
     */
    statics: 'DEFINE_MANY',

/**
     * Definition of prop types for this component.
     *
     * @type {object}
     * @optional
     */
    propTypes: 'DEFINE_MANY',

/**
     * Definition of context types for this component.
     *
     * @type {object}
     * @optional
     */
    contextTypes: 'DEFINE_MANY',

/**
     * Definition of context types this component sets for its children.
     *
     * @type {object}
     * @optional
     */
    childContextTypes: 'DEFINE_MANY',

// ==== Definition methods ====

/**
     * Invoked when the component is mounted. Values in the mapping will be set on
     * `this.props` if that prop is not specified (i.e. using an `in` check).
     *
     * This method is invoked before `getInitialState` and therefore cannot rely
     * on `this.state` or use `this.setState`.
     *
     * @return {object}
     * @optional
     */
    getDefaultProps: 'DEFINE_MANY_MERGED',

/**
     * Invoked once before the component is mounted. The return value will be used
     * as the initial value of `this.state`.
     *
     *   getInitialState: function() {
     *     return {
     *       isOn: false,
     *       fooBaz: new BazFoo()
     *     }
     *   }
     *
     * @return {object}
     * @optional
     */
    getInitialState: 'DEFINE_MANY_MERGED',

/**
     * @return {object}
     * @optional
     */
    getChildContext: 'DEFINE_MANY_MERGED',

/**
     * Uses props from `this.props` and state from `this.state` to render the
     * structure of the component.
     *
     * No guarantees are made about when or how often this method is invoked, so
     * it must not have side effects.
     *
     *   render: function() {
     *     var name = this.props.name;
     *     return <div>Hello, {name}!</div>;
     *   }
     *
     * @return {ReactComponent}
     * @required
     */
    render: 'DEFINE_ONCE',

// ==== Delegate methods ====

/**
     * Invoked when the component is initially created and about to be mounted.
     * This may have side effects, but any external subscriptions or data created
     * by this method must be cleaned up in `componentWillUnmount`.
     *
     * @optional
     */
    componentWillMount: 'DEFINE_MANY',

/**
     * Invoked when the component has been mounted and has a DOM representation.
     * However, there is no guarantee that the DOM node is in the document.
     *
     * Use this as an opportunity to operate on the DOM when the component has
     * been mounted (initialized and rendered) for the first time.
     *
     * @param {DOMElement} rootNode DOM element representing the component.
     * @optional
     */
    componentDidMount: 'DEFINE_MANY',

/**
     * Invoked before the component receives new props.
     *
     * Use this as an opportunity to react to a prop transition by updating the
     * state using `this.setState`. Current props are accessed via `this.props`.
     *
     *   componentWillReceiveProps: function(nextProps, nextContext) {
     *     this.setState({
     *       likesIncreasing: nextProps.likeCount > this.props.likeCount
     *     });
     *   }
     *
     * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop
     * transition may cause a state change, but the opposite is not true. If you
     * need it, you are probably looking for `componentWillUpdate`.
     *
     * @param {object} nextProps
     * @optional
     */
    componentWillReceiveProps: 'DEFINE_MANY',

/**
     * Invoked while deciding if the component should be updated as a result of
     * receiving new props, state and/or context.
     *
     * Use this as an opportunity to `return false` when you're certain that the
     * transition to the new props/state/context will not require a component
     * update.
     *
     *   shouldComponentUpdate: function(nextProps, nextState, nextContext) {
     *     return !equal(nextProps, this.props) ||
     *       !equal(nextState, this.state) ||
     *       !equal(nextContext, this.context);
     *   }
     *
     * @param {object} nextProps
     * @param {?object} nextState
     * @param {?object} nextContext
     * @return {boolean} True if the component should update.
     * @optional
     */
    shouldComponentUpdate: 'DEFINE_ONCE',

/**
     * Invoked when the component is about to update due to a transition from
     * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`
     * and `nextContext`.
     *
     * Use this as an opportunity to perform preparation before an update occurs.
     *
     * NOTE: You **cannot** use `this.setState()` in this method.
     *
     * @param {object} nextProps
     * @param {?object} nextState
     * @param {?object} nextContext
     * @param {ReactReconcileTransaction} transaction
     * @optional
     */
    componentWillUpdate: 'DEFINE_MANY',

/**
     * Invoked when the component's DOM representation has been updated.
     *
     * Use this as an opportunity to operate on the DOM when the component has
     * been updated.
     *
     * @param {object} prevProps
     * @param {?object} prevState
     * @param {?object} prevContext
     * @param {DOMElement} rootNode DOM element representing the component.
     * @optional
     */
    componentDidUpdate: 'DEFINE_MANY',

/**
     * Invoked when the component is about to be removed from its parent and have
     * its DOM representation destroyed.
     *
     * Use this as an opportunity to deallocate any external resources.
     *
     * NOTE: There is no `componentDidUnmount` since your component will have been
     * destroyed by that point.
     *
     * @optional
     */
    componentWillUnmount: 'DEFINE_MANY',

/**
     * Replacement for (deprecated) `componentWillMount`.
     *
     * @optional
     */
    UNSAFE_componentWillMount: 'DEFINE_MANY',

/**
     * Replacement for (deprecated) `componentWillReceiveProps`.
     *
     * @optional
     */
    UNSAFE_componentWillReceiveProps: 'DEFINE_MANY',

/**
     * Replacement for (deprecated) `componentWillUpdate`.
     *
     * @optional
     */
    UNSAFE_componentWillUpdate: 'DEFINE_MANY',

// ==== Advanced methods ====

/**
     * Updates the component's currently mounted DOM representation.
     *
     * By default, this implements React's rendering and reconciliation algorithm.
     * Sophisticated clients may wish to override this.
     *
     * @param {ReactReconcileTransaction} transaction
     * @internal
     * @overridable
     */
    updateComponent: 'OVERRIDE_BASE'
  };

/**
   * Similar to ReactClassInterface but for static methods.
   */
  var ReactClassStaticInterface = {
    /**
     * This method is invoked after a component is instantiated and when it
     * receives new props. Return an object to update state in response to
     * prop changes. Return null to indicate no change to state.
     *
     * If an object is returned, its keys will be merged into the existing state.
     *
     * @return {object || null}
     * @optional
     */
    getDerivedStateFromProps: 'DEFINE_MANY_MERGED'
  };

/**
   * Mapping from class specification keys to special processing functions.
   *
   * Although these are declared like instance properties in the specification
   * when defining classes using `React.createClass`, they are actually static
   * and are accessible on the constructor instead of the prototype. Despite
   * being static, they must be defined outside of the "statics" key under
   * which all other static methods are defined.
   */
  var RESERVED_SPEC_KEYS = {
    displayName: function(Constructor, displayName) {
      Constructor.displayName = displayName;
    },
    mixins: function(Constructor, mixins) {
      if (mixins) {
        for (var i = 0; i < mixins.length; i++) {
          mixSpecIntoComponent(Constructor, mixins[i]);
        }
      }
    },
    childContextTypes: function(Constructor, childContextTypes) {
      if (process.env.NODE_ENV !== 'production') {
        validateTypeDef(Constructor, childContextTypes, 'childContext');
      }
      Constructor.childContextTypes = _assign(
        {},
        Constructor.childContextTypes,
        childContextTypes
      );
    },
    contextTypes: function(Constructor, contextTypes) {
      if (process.env.NODE_ENV !== 'production') {
        validateTypeDef(Constructor, contextTypes, 'context');
      }
      Constructor.contextTypes = _assign(
        {},
        Constructor.contextTypes,
        contextTypes
      );
    },
    /**
     * Special case getDefaultProps which should move into statics but requires
     * automatic merging.
     */
    getDefaultProps: function(Constructor, getDefaultProps) {
      if (Constructor.getDefaultProps) {
        Constructor.getDefaultProps = createMergedResultFunction(
          Constructor.getDefaultProps,
          getDefaultProps
        );
      } else {
        Constructor.getDefaultProps = getDefaultProps;
      }
    },
    propTypes: function(Constructor, propTypes) {
      if (process.env.NODE_ENV !== 'production') {
        validateTypeDef(Constructor, propTypes, 'prop');
      }
      Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes);
    },
    statics: function(Constructor, statics) {
      mixStaticSpecIntoComponent(Constructor, statics);
    },
    autobind: function() {}
  };

function validateTypeDef(Constructor, typeDef, location) {
    for (var propName in typeDef) {
      if (typeDef.hasOwnProperty(propName)) {
        // use a warning instead of an _invariant so components
        // don't show up in prod but only in __DEV__
        if (process.env.NODE_ENV !== 'production') {
          warning(
            typeof typeDef[propName] === 'function',
            '%s: %s type `%s` is invalid; it must be a function, usually from ' +
              'React.PropTypes.',
            Constructor.displayName || 'ReactClass',
            ReactPropTypeLocationNames[location],
            propName
          );
        }
      }
    }
  }

function validateMethodOverride(isAlreadyDefined, name) {
    var specPolicy = ReactClassInterface.hasOwnProperty(name)
      ? ReactClassInterface[name]
      : null;

// Disallow overriding of base class methods unless explicitly allowed.
    if (ReactClassMixin.hasOwnProperty(name)) {
      _invariant(
        specPolicy === 'OVERRIDE_BASE',
        'ReactClassInterface: You are attempting to override ' +
          '`%s` from your class specification. Ensure that your method names ' +
          'do not overlap with React methods.',
        name
      );
    }

// Disallow defining methods more than once unless explicitly allowed.
    if (isAlreadyDefined) {
      _invariant(
        specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED',
        'ReactClassInterface: You are attempting to define ' +
          '`%s` on your component more than once. This conflict may be due ' +
          'to a mixin.',
        name
      );
    }
  }

/**
   * Mixin helper which handles policy validation and reserved
   * specification keys when building React classes.
   */
  function mixSpecIntoComponent(Constructor, spec) {
    if (!spec) {
      if (process.env.NODE_ENV !== 'production') {
        var typeofSpec = typeof spec;
        var isMixinValid = typeofSpec === 'object' && spec !== null;

if (process.env.NODE_ENV !== 'production') {
          warning(
            isMixinValid,
            "%s: You're attempting to include a mixin that is either null " +
              'or not an object. Check the mixins included by the component, ' +
              'as well as any mixins they include themselves. ' +
              'Expected object but got %s.',
            Constructor.displayName || 'ReactClass',
            spec === null ? null : typeofSpec
          );
        }
      }

return;
    }

_invariant(
      typeof spec !== 'function',
      "ReactClass: You're attempting to " +
        'use a component class or function as a mixin. Instead, just use a ' +
        'regular object.'
    );
    _invariant(
      !isValidElement(spec),
      "ReactClass: You're attempting to " +
        'use a component as a mixin. Instead, just use a regular object.'
    );

var proto = Constructor.prototype;
    var autoBindPairs = proto.__reactAutoBindPairs;

// By handling mixins before any other properties, we ensure the same
    // chaining order is applied to methods with DEFINE_MANY policy, whether
    // mixins are listed before or after these methods in the spec.
    if (spec.hasOwnProperty(MIXINS_KEY)) {
      RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
    }

for (var name in spec) {
      if (!spec.hasOwnProperty(name)) {
        continue;
      }

if (name === MIXINS_KEY) {
        // We have already handled mixins in a special case above.
        continue;
      }

var property = spec[name];
      var isAlreadyDefined = proto.hasOwnProperty(name);
      validateMethodOverride(isAlreadyDefined, name);

if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
        RESERVED_SPEC_KEYS[name](Constructor, property);
      } else {
        // Setup methods on prototype:
        // The following member methods should not be automatically bound:
        // 1. Expected ReactClass methods (in the "interface").
        // 2. Overridden methods (that were mixed in).
        var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
        var isFunction = typeof property === 'function';
        var shouldAutoBind =
          isFunction &&
          !isReactClassMethod &&
          !isAlreadyDefined &&
          spec.autobind !== false;

if (shouldAutoBind) {
          autoBindPairs.push(name, property);
          proto[name] = property;
        } else {
          if (isAlreadyDefined) {
            var specPolicy = ReactClassInterface[name];

// These cases should already be caught by validateMethodOverride.
            _invariant(
              isReactClassMethod &&
                (specPolicy === 'DEFINE_MANY_MERGED' ||
                  specPolicy === 'DEFINE_MANY'),
              'ReactClass: Unexpected spec policy %s for key %s ' +
                'when mixing in component specs.',
              specPolicy,
              name
            );

// For methods which are defined more than once, call the existing
            // methods before calling the new property, merging if appropriate.
            if (specPolicy === 'DEFINE_MANY_MERGED') {
              proto[name] = createMergedResultFunction(proto[name], property);
            } else if (specPolicy === 'DEFINE_MANY') {
              proto[name] = createChainedFunction(proto[name], property);
            }
          } else {
            proto[name] = property;
            if (process.env.NODE_ENV !== 'production') {
              // Add verbose displayName to the function, which helps when looking
              // at profiling tools.
              if (typeof property === 'function' && spec.displayName) {
                proto[name].displayName = spec.displayName + '_' + name;
              }
            }
          }
        }
      }
    }
  }

function mixStaticSpecIntoComponent(Constructor, statics) {
    if (!statics) {
      return;
    }

for (var name in statics) {
      var property = statics[name];
      if (!statics.hasOwnProperty(name)) {
        continue;
      }

var isReserved = name in RESERVED_SPEC_KEYS;
      _invariant(
        !isReserved,
        'ReactClass: You are attempting to define a reserved ' +
          'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' +
          'as an instance property instead; it will still be accessible on the ' +
          'constructor.',
        name
      );

var isAlreadyDefined = name in Constructor;
      if (isAlreadyDefined) {
        var specPolicy = ReactClassStaticInterface.hasOwnProperty(name)
          ? ReactClassStaticInterface[name]
          : null;

_invariant(
          specPolicy === 'DEFINE_MANY_MERGED',
          'ReactClass: You are attempting to define ' +
            '`%s` on your component more than once. This conflict may be ' +
            'due to a mixin.',
          name
        );

Constructor[name] = createMergedResultFunction(Constructor[name], property);

return;
      }

Constructor[name] = property;
    }
  }

/**
   * Merge two objects, but throw if both contain the same key.
   *
   * @param {object} one The first object, which is mutated.
   * @param {object} two The second object
   * @return {object} one after it has been mutated to contain everything in two.
   */
  function mergeIntoWithNoDuplicateKeys(one, two) {
    _invariant(
      one && two && typeof one === 'object' && typeof two === 'object',
      'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.'
    );

for (var key in two) {
      if (two.hasOwnProperty(key)) {
        _invariant(
          one[key] === undefined,
          'mergeIntoWithNoDuplicateKeys(): ' +
            'Tried to merge two objects with the same key: `%s`. This conflict ' +
            'may be due to a mixin; in particular, this may be caused by two ' +
            'getInitialState() or getDefaultProps() methods returning objects ' +
            'with clashing keys.',
          key
        );
        one[key] = two[key];
      }
    }
    return one;
  }

/**
   * Creates a function that invokes two functions and merges their return values.
   *
   * @param {function} one Function to invoke first.
   * @param {function} two Function to invoke second.
   * @return {function} Function that invokes the two argument functions.
   * @private
   */
  function createMergedResultFunction(one, two) {
    return function mergedResult() {
      var a = one.apply(this, arguments);
      var b = two.apply(this, arguments);
      if (a == null) {
        return b;
      } else if (b == null) {
        return a;
      }
      var c = {};
      mergeIntoWithNoDuplicateKeys(c, a);
      mergeIntoWithNoDuplicateKeys(c, b);
      return c;
    };
  }

/**
   * Creates a function that invokes two functions and ignores their return vales.
   *
   * @param {function} one Function to invoke first.
   * @param {function} two Function to invoke second.
   * @return {function} Function that invokes the two argument functions.
   * @private
   */
  function createChainedFunction(one, two) {
    return function chainedFunction() {
      one.apply(this, arguments);
      two.apply(this, arguments);
    };
  }

/**
   * Binds a method to the component.
   *
   * @param {object} component Component whose method is going to be bound.
   * @param {function} method Method to be bound.
   * @return {function} The bound method.
   */
  function bindAutoBindMethod(component, method) {
    var boundMethod = method.bind(component);
    if (process.env.NODE_ENV !== 'production') {
      boundMethod.__reactBoundContext = component;
      boundMethod.__reactBoundMethod = method;
      boundMethod.__reactBoundArguments = null;
      var componentName = component.constructor.displayName;
      var _bind = boundMethod.bind;
      boundMethod.bind = function(newThis) {
        for (
          var _len = arguments.length,
            args = Array(_len > 1 ? _len - 1 : 0),
            _key = 1;
          _key < _len;
          _key++
        ) {
          args[_key - 1] = arguments[_key];
        }

// User is trying to bind() an autobound method; we effectively will
        // ignore the value of "this" that the user is trying to use, so
        // let's warn.
        if (newThis !== component && newThis !== null) {
          if (process.env.NODE_ENV !== 'production') {
            warning(
              false,
              'bind(): React component methods may only be bound to the ' +
                'component instance. See %s',
              componentName
            );
          }
        } else if (!args.length) {
          if (process.env.NODE_ENV !== 'production') {
            warning(
              false,
              'bind(): You are binding a component method to the component. ' +
                'React does this for you automatically in a high-performance ' +
                'way, so you can safely remove this call. See %s',
              componentName
            );
          }
          return boundMethod;
        }
        var reboundMethod = _bind.apply(boundMethod, arguments);
        reboundMethod.__reactBoundContext = component;
        reboundMethod.__reactBoundMethod = method;
        reboundMethod.__reactBoundArguments = args;
        return reboundMethod;
      };
    }
    return boundMethod;
  }

/**
   * Binds all auto-bound methods in a component.
   *
   * @param {object} component Component whose method is going to be bound.
   */
  function bindAutoBindMethods(component) {
    var pairs = component.__reactAutoBindPairs;
    for (var i = 0; i < pairs.length; i += 2) {
      var autoBindKey = pairs[i];
      var method = pairs[i + 1];
      component[autoBindKey] = bindAutoBindMethod(component, method);
    }
  }

var IsMountedPreMixin = {
    componentDidMount: function() {
      this.__isMounted = true;
    }
  };

var IsMountedPostMixin = {
    componentWillUnmount: function() {
      this.__isMounted = false;
    }
  };

/**
   * Add more to the ReactClass base class. These are all legacy features and
   * therefore not already part of the modern ReactComponent.
   */
  var ReactClassMixin = {
    /**
     * TODO: This will be deprecated because state should always keep a consistent
     * type signature and the only use case for this, is to avoid that.
     */
    replaceState: function(newState, callback) {
      this.updater.enqueueReplaceState(this, newState, callback);
    },

/**
     * Checks whether or not this composite component is mounted.
     * @return {boolean} True if mounted, false otherwise.
     * @protected
     * @final
     */
    isMounted: function() {
      if (process.env.NODE_ENV !== 'production') {
        warning(
          this.__didWarnIsMounted,
          '%s: isMounted is deprecated. Instead, make sure to clean up ' +
            'subscriptions and pending requests in componentWillUnmount to ' +
            'prevent memory leaks.',
          (this.constructor && this.constructor.displayName) ||
            this.name ||
            'Component'
        );
        this.__didWarnIsMounted = true;
      }
      return !!this.__isMounted;
    }
  };

var ReactClassComponent = function() {};
  _assign(
    ReactClassComponent.prototype,
    ReactComponent.prototype,
    ReactClassMixin
  );

/**
   * Creates a composite component class given a class specification.
   * See https://facebook.github.io/react/docs/top-level-api.html#react.createclass
   *
   * @param {object} spec Class specification (which must define `render`).
   * @return {function} Component constructor function.
   * @public
   */
  function createClass(spec) {
    // To keep our warnings more understandable, we'll use a little hack here to
    // ensure that Constructor.name !== 'Constructor'. This makes sure we don't
    // unnecessarily identify a class without displayName as 'Constructor'.
    var Constructor = identity(function(props, context, updater) {
      // This constructor gets overridden by mocks. The argument is used
      // by mocks to assert on what gets mounted.

if (process.env.NODE_ENV !== 'production') {
        warning(
          this instanceof Constructor,
          'Something is calling a React component directly. Use a factory or ' +
            'JSX instead. See: https://fb.me/react-legacyfactory'
        );
      }

// Wire up auto-binding
      if (this.__reactAutoBindPairs.length) {
        bindAutoBindMethods(this);
      }

this.props = props;
      this.context = context;
      this.refs = emptyObject;
      this.updater = updater || ReactNoopUpdateQueue;

this.state = null;

// ReactClasses doesn't have constructors. Instead, they use the
      // getInitialState and componentWillMount methods for initialization.

var initialState = this.getInitialState ? this.getInitialState() : null;
      if (process.env.NODE_ENV !== 'production') {
        // We allow auto-mocks to proceed as if they're returning null.
        if (
          initialState === undefined &&
          this.getInitialState._isMockFunction
        ) {
          // This is probably bad practice. Consider warning here and
          // deprecating this convenience.
          initialState = null;
        }
      }
      _invariant(
        typeof initialState === 'object' && !Array.isArray(initialState),
        '%s.getInitialState(): must return an object or null',
        Constructor.displayName || 'ReactCompositeComponent'
      );

this.state = initialState;
    });
    Constructor.prototype = new ReactClassComponent();
    Constructor.prototype.constructor = Constructor;
    Constructor.prototype.__reactAutoBindPairs = [];

injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));

mixSpecIntoComponent(Constructor, IsMountedPreMixin);
    mixSpecIntoComponent(Constructor, spec);
    mixSpecIntoComponent(Constructor, IsMountedPostMixin);

// Initialize the defaultProps property after all mixins have been merged.
    if (Constructor.getDefaultProps) {
      Constructor.defaultProps = Constructor.getDefaultProps();
    }

_invariant(
      Constructor.prototype.render,
      'createClass(...): Class specification must implement a `render` method.'
    );

if (process.env.NODE_ENV !== 'production') {
      warning(
        !Constructor.prototype.componentShouldUpdate,
        '%s has a method called ' +
          'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' +
          'The name is phrased as a question because the function is ' +
          'expected to return a value.',
        spec.displayName || 'A component'
      );
      warning(
        !Constructor.prototype.componentWillRecieveProps,
        '%s has a method called ' +
          'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?',
        spec.displayName || 'A component'
      );
      warning(
        !Constructor.prototype.UNSAFE_componentWillRecieveProps,
        '%s has a method called UNSAFE_componentWillRecieveProps(). ' +
          'Did you mean UNSAFE_componentWillReceiveProps()?',
        spec.displayName || 'A component'
      );
    }

return Constructor;
  }

return createClass;
}

module.exports = factory;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 838 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

var React = __webpack_require__(0);
var factory = __webpack_require__(837);

if (typeof React === 'undefined') {
  throw Error(
    'create-react-class could not find the React object. If you are using script tags, ' +
      'make sure that React is being loaded before create-react-class.'
  );
}

// Hack to grab NoopUpdateQueue from isomorphic React
var ReactNoopUpdateQueue = new React.Component().updater;

module.exports = factory(
  React.Component,
  React.isValidElement,
  ReactNoopUpdateQueue
);

/***/ }),
/* 839 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _gud = __webpack_require__(945);

var _gud2 = _interopRequireDefault(_gud);

var _warning = __webpack_require__(18);

var _warning2 = _interopRequireDefault(_warning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var MAX_SIGNED_31_BIT_INT = 1073741823;

// Inlined Object.is polyfill.
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
function objectIs(x, y) {
  if (x === y) {
    return x !== 0 || 1 / x === 1 / y;
  } else {
    return x !== x && y !== y;
  }
}

function onlyChild(children) {
  return Array.isArray(children) ? children[0] : children;
}

function createReactContext(defaultValue, calculateChangedBits) {
  var _Provider$childContex, _Consumer$contextType;

var contextProp = '__create-react-context-' + (0, _gud2.default)() + '__';

var Provider = function (_Component) {
    _inherits(Provider, _Component);

function Provider() {
      var _temp, _this, _ret;

_classCallCheck(this, Provider);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.emitter = createEventEmitter(_this.props.value), _temp), _possibleConstructorReturn(_this, _ret);
    }

Provider.prototype.getChildContext = function getChildContext() {
      var _ref;

return _ref = {}, _ref[contextProp] = this.emitter, _ref;
    };

Provider.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
      if (this.props.value !== nextProps.value) {
        var oldValue = this.props.value;
        var newValue = nextProps.value;
        var changedBits = void 0;

if (objectIs(oldValue, newValue)) {
          changedBits = 0; // No change
        } else {
          changedBits = typeof calculateChangedBits === 'function' ? calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;
          if (process.env.NODE_ENV !== 'production') {
            (0, _warning2.default)((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits, 'calculateChangedBits: Expected the return value to be a ' + '31-bit integer. Instead received: %s', changedBits);
          }

changedBits |= 0;

if (changedBits !== 0) {
            this.emitter.set(nextProps.value, changedBits);
          }
        }
      }
    };

Provider.prototype.render = function render() {
      return this.props.children;
    };

return Provider;
  }(_react.Component);

Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = _propTypes2.default.object.isRequired, _Provider$childContex);

var Consumer = function (_Component2) {
    _inherits(Consumer, _Component2);

function Consumer() {
      var _temp2, _this2, _ret2;

_classCallCheck(this, Consumer);

for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }

return _ret2 = (_temp2 = (_this2 = _possibleConstructorReturn(this, _Component2.call.apply(_Component2, [this].concat(args))), _this2), _this2.state = {
        value: _this2.getValue()
      }, _this2.onUpdate = function (newValue, changedBits) {
        var observedBits = _this2.observedBits | 0;
        if ((observedBits & changedBits) !== 0) {
          _this2.setState({ value: _this2.getValue() });
        }
      }, _temp2), _possibleConstructorReturn(_this2, _ret2);
    }

Consumer.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
      var observedBits = nextProps.observedBits;

this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT // Subscribe to all changes by default
      : observedBits;
    };

Consumer.prototype.componentDidMount = function componentDidMount() {
      if (this.context[contextProp]) {
        this.context[contextProp].on(this.onUpdate);
      }
      var observedBits = this.props.observedBits;

this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT // Subscribe to all changes by default
      : observedBits;
    };

Consumer.prototype.componentWillUnmount = function componentWillUnmount() {
      if (this.context[contextProp]) {
        this.context[contextProp].off(this.onUpdate);
      }
    };

Consumer.prototype.getValue = function getValue() {
      if (this.context[contextProp]) {
        return this.context[contextProp].get();
      } else {
        return defaultValue;
      }
    };

Consumer.prototype.render = function render() {
      return onlyChild(this.props.children)(this.state.value);
    };

return Consumer;
  }(_react.Component);

Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = _propTypes2.default.object, _Consumer$contextType);

return {
    Provider: Provider,
    Consumer: Consumer
  };
}

exports.default = createReactContext;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 840 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _implementation = __webpack_require__(839);

var _implementation2 = _interopRequireDefault(_implementation);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _react2.default.createContext || _implementation2.default;
module.exports = exports['default'];

/***/ }),
/* 841 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(261)(undefined);
// imports

// module
exports.push([module.i, ".frame-loader-container {\r\n    background: #fff;\r\n    height: 100vh;\r\n    display: flex;\r\n    justify-content: center;\r\n    flex-direction: column;\r\n  }\r\n  .frame-loader-row-wrap {\r\n    max-width: 70%;\r\n    margin: 0 auto;\r\n    width : 100%;\r\n    margin-bottom: 50px;\r\n  }\r\n  .frame-loader-row-wrap:last-child {\r\n    margin-bottom: 0;\r\n  }\r\n  .frame-loader-row {\r\n    display: flex;\r\n    align-items: center;\r\n    margin: 0 -20px;\r\n  }\r\n  .frame-loader-col {\r\n    width: 50%;\r\n    padding: 0 20px;\r\n  }\r\n  ", ""]);

// exports

/***/ }),
/* 842 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(261)(undefined);
// imports

// module
exports.push([module.i, "/* BASICS */\n\n.CodeMirror {\n  /* Set height, width, borders, and global font properties here */\n  font-family: monospace;\n  height: 300px;\n  color: black;\n  direction: ltr;\n}\n\n/* PADDING */\n\n.CodeMirror-lines {\n  padding: 4px 0; /* Vertical padding around content */\n}\n.CodeMirror pre {\n  padding: 0 4px; /* Horizontal padding of content */\n}\n\n.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n  background-color: white; /* The little square between H and V scrollbars */\n}\n\n/* GUTTER */\n\n.CodeMirror-gutters {\n  border-right: 1px solid #ddd;\n  background-color: #f7f7f7;\n  white-space: nowrap;\n}\n.CodeMirror-linenumbers {}\n.CodeMirror-linenumber {\n  padding: 0 3px 0 5px;\n  min-width: 20px;\n  text-align: right;\n  color: #999;\n  white-space: nowrap;\n}\n\n.CodeMirror-guttermarker { color: black; }\n.CodeMirror-guttermarker-subtle { color: #999; }\n\n/* CURSOR */\n\n.CodeMirror-cursor {\n  border-left: 1px solid black;\n  border-right: none;\n  width: 0;\n}\n/* Shown when moving in bi-directional text */\n.CodeMirror div.CodeMirror-secondarycursor {\n  border-left: 1px solid silver;\n}\n.cm-fat-cursor .CodeMirror-cursor {\n  width: auto;\n  border: 0 !important;\n  background: #7e7;\n}\n.cm-fat-cursor div.CodeMirror-cursors {\n  z-index: 1;\n}\n.cm-fat-cursor-mark {\n  background-color: rgba(20, 255, 20, 0.5);\n  -webkit-animation: blink 1.06s steps(1) infinite;\n  -moz-animation: blink 1.06s steps(1) infinite;\n  animation: blink 1.06s steps(1) infinite;\n}\n.cm-animate-fat-cursor {\n  width: auto;\n  border: 0;\n  -webkit-animation: blink 1.06s steps(1) infinite;\n  -moz-animation: blink 1.06s steps(1) infinite;\n  animation: blink 1.06s steps(1) infinite;\n  background-color: #7e7;\n}\n@-moz-keyframes blink {\n  0% {}\n  50% { background-color: transparent; }\n  100% {}\n}\n@-webkit-keyframes blink {\n  0% {}\n  50% { background-color: transparent; }\n  100% {}\n}\n@keyframes blink {\n  0% {}\n  50% { background-color: transparent; }\n  100% {}\n}\n\n/* Can style cursor different in overwrite (non-insert) mode */\n.CodeMirror-overwrite .CodeMirror-cursor {}\n\n.cm-tab { display: inline-block; text-decoration: inherit; }\n\n.CodeMirror-rulers {\n  position: absolute;\n  left: 0; right: 0; top: -50px; bottom: -20px;\n  overflow: hidden;\n}\n.CodeMirror-ruler {\n  border-left: 1px solid #ccc;\n  top: 0; bottom: 0;\n  position: absolute;\n}\n\n/* DEFAULT THEME */\n\n.cm-s-default .cm-header {color: blue;}\n.cm-s-default .cm-quote {color: #090;}\n.cm-negative {color: #d44;}\n.cm-positive {color: #292;}\n.cm-header, .cm-strong {font-weight: bold;}\n.cm-em {font-style: italic;}\n.cm-link {text-decoration: underline;}\n.cm-strikethrough {text-decoration: line-through;}\n\n.cm-s-default .cm-keyword {color: #708;}\n.cm-s-default .cm-atom {color: #219;}\n.cm-s-default .cm-number {color: #164;}\n.cm-s-default .cm-def {color: #00f;}\n.cm-s-default .cm-variable,\n.cm-s-default .cm-punctuation,\n.cm-s-default .cm-property,\n.cm-s-default .cm-operator {}\n.cm-s-default .cm-variable-2 {color: #05a;}\n.cm-s-default .cm-variable-3, .cm-s-default .cm-type {color: #085;}\n.cm-s-default .cm-comment {color: #a50;}\n.cm-s-default .cm-string {color: #a11;}\n.cm-s-default .cm-string-2 {color: #f50;}\n.cm-s-default .cm-meta {color: #555;}\n.cm-s-default .cm-qualifier {color: #555;}\n.cm-s-default .cm-builtin {color: #30a;}\n.cm-s-default .cm-bracket {color: #997;}\n.cm-s-default .cm-tag {color: #170;}\n.cm-s-default .cm-attribute {color: #00c;}\n.cm-s-default .cm-hr {color: #999;}\n.cm-s-default .cm-link {color: #00c;}\n\n.cm-s-default .cm-error {color: #f00;}\n.cm-invalidchar {color: #f00;}\n\n.CodeMirror-composing { border-bottom: 2px solid; }\n\n/* Default styles for common addons */\n\ndiv.CodeMirror span.CodeMirror-matchingbracket {color: #0b0;}\ndiv.CodeMirror span.CodeMirror-nonmatchingbracket {color: #a22;}\n.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }\n.CodeMirror-activeline-background {background: #e8f2ff;}\n\n/* STOP */\n\n/* The rest of this file contains styles related to the mechanics of\n   the editor. You probably shouldn't touch them. */\n\n.CodeMirror {\n  position: relative;\n  overflow: hidden;\n  background: white;\n}\n\n.CodeMirror-scroll {\n  overflow: scroll !important; /* Things will break if this is overridden */\n  /* 30px is the magic margin used to hide the element's real scrollbars */\n  /* See overflow: hidden in .CodeMirror */\n  margin-bottom: -30px; margin-right: -30px;\n  padding-bottom: 30px;\n  height: 100%;\n  outline: none; /* Prevent dragging from highlighting the element */\n  position: relative;\n}\n.CodeMirror-sizer {\n  position: relative;\n  border-right: 30px solid transparent;\n}\n\n/* The fake, visible scrollbars. Used to force redraw during scrolling\n   before actual scrolling happens, thus preventing shaking and\n   flickering artifacts. */\n.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n  position: absolute;\n  z-index: 6;\n  display: none;\n}\n.CodeMirror-vscrollbar {\n  right: 0; top: 0;\n  overflow-x: hidden;\n  overflow-y: scroll;\n}\n.CodeMirror-hscrollbar {\n  bottom: 0; left: 0;\n  overflow-y: hidden;\n  overflow-x: scroll;\n}\n.CodeMirror-scrollbar-filler {\n  right: 0; bottom: 0;\n}\n.CodeMirror-gutter-filler {\n  left: 0; bottom: 0;\n}\n\n.CodeMirror-gutters {\n  position: absolute; left: 0; top: 0;\n  min-height: 100%;\n  z-index: 3;\n}\n.CodeMirror-gutter {\n  white-space: normal;\n  height: 100%;\n  display: inline-block;\n  vertical-align: top;\n  margin-bottom: -30px;\n}\n.CodeMirror-gutter-wrapper {\n  position: absolute;\n  z-index: 4;\n  background: none !important;\n  border: none !important;\n}\n.CodeMirror-gutter-background {\n  position: absolute;\n  top: 0; bottom: 0;\n  z-index: 4;\n}\n.CodeMirror-gutter-elt {\n  position: absolute;\n  cursor: default;\n  z-index: 4;\n}\n.CodeMirror-gutter-wrapper ::selection { background-color: transparent }\n.CodeMirror-gutter-wrapper ::-moz-selection { background-color: transparent }\n\n.CodeMirror-lines {\n  cursor: text;\n  min-height: 1px; /* prevents collapsing before first draw */\n}\n.CodeMirror pre {\n  /* Reset some styles that the rest of the page might have set */\n  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;\n  border-width: 0;\n  background: transparent;\n  font-family: inherit;\n  font-size: inherit;\n  margin: 0;\n  white-space: pre;\n  word-wrap: normal;\n  line-height: inherit;\n  color: inherit;\n  z-index: 2;\n  position: relative;\n  overflow: visible;\n  -webkit-tap-highlight-color: transparent;\n  -webkit-font-variant-ligatures: contextual;\n  font-variant-ligatures: contextual;\n}\n.CodeMirror-wrap pre {\n  word-wrap: break-word;\n  white-space: pre-wrap;\n  word-break: normal;\n}\n\n.CodeMirror-linebackground {\n  position: absolute;\n  left: 0; right: 0; top: 0; bottom: 0;\n  z-index: 0;\n}\n\n.CodeMirror-linewidget {\n  position: relative;\n  z-index: 2;\n  padding: 0.1px; /* Force widget margins to stay inside of the container */\n}\n\n.CodeMirror-widget {}\n\n.CodeMirror-rtl pre { direction: rtl; }\n\n.CodeMirror-code {\n  outline: none;\n}\n\n/* Force content-box sizing for the elements where we expect it */\n.CodeMirror-scroll,\n.CodeMirror-sizer,\n.CodeMirror-gutter,\n.CodeMirror-gutters,\n.CodeMirror-linenumber {\n  -moz-box-sizing: content-box;\n  box-sizing: content-box;\n}\n\n.CodeMirror-measure {\n  position: absolute;\n  width: 100%;\n  height: 0;\n  overflow: hidden;\n  visibility: hidden;\n}\n\n.CodeMirror-cursor {\n  position: absolute;\n  pointer-events: none;\n}\n.CodeMirror-measure pre { position: static; }\n\ndiv.CodeMirror-cursors {\n  visibility: hidden;\n  position: relative;\n  z-index: 3;\n}\ndiv.CodeMirror-dragcursors {\n  visibility: visible;\n}\n\n.CodeMirror-focused div.CodeMirror-cursors {\n  visibility: visible;\n}\n\n.CodeMirror-selected { background: #d9d9d9; }\n.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }\n.CodeMirror-crosshair { cursor: crosshair; }\n.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }\n.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }\n\n.cm-searching {\n  background-color: #ffa;\n  background-color: rgba(255, 255, 0, .4);\n}\n\n/* Used to force a border model for a node */\n.cm-force-border { padding-right: .1px; }\n\n@media print {\n  /* Hide the cursor when printing */\n  .CodeMirror div.CodeMirror-cursors {\n    visibility: hidden;\n  }\n}\n\n/* See issue #2901 */\n.cm-tab-wrap-hack:after { content: ''; }\n\n/* Help users use markselection to safely style text background */\nspan.CodeMirror-selectedtext { background: none; }\n", ""]);

// exports

/***/ }),
/* 843 */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(261)(undefined);
// imports

// module
exports.push([module.i, ".rc-collapse {\n  background-color: #f7f7f7;\n  border-radius: 3px;\n  border: 1px solid #d9d9d9;\n}\n.rc-collapse-anim-active {\n  transition: height 0.2s ease-out;\n}\n.rc-collapse > .rc-collapse-item {\n  border-top: 1px solid #d9d9d9;\n}\n.rc-collapse > .rc-collapse-item:first-child {\n  border-top: none;\n}\n.rc-collapse > .rc-collapse-item > .rc-collapse-header {\n  height: 38px;\n  line-height: 38px;\n  text-indent: 16px;\n  color: #666;\n  cursor: pointer;\n}\n.rc-collapse > .rc-collapse-item > .rc-collapse-header .arrow {\n  display: inline-block;\n  content: ' ';\n  width: 0;\n  height: 0;\n  font-size: 0;\n  line-height: 0;\n  border-top: 3px solid transparent;\n  border-bottom: 3px solid transparent;\n  border-left: 4px solid #666;\n  vertical-align: middle;\n  margin-right: 8px;\n}\n.rc-collapse > .rc-collapse-item-disabled > .rc-collapse-header {\n  cursor: not-allowed;\n  color: #999;\n  background-color: #f3f3f3;\n}\n.rc-collapse-content {\n  overflow: hidden;\n  color: #666;\n  padding: 0 16px;\n  background-color: #fff;\n}\n.rc-collapse-content > .rc-collapse-content-box {\n  margin-top: 16px;\n  margin-bottom: 16px;\n}\n.rc-collapse-content-inactive {\n  display: none;\n}\n.rc-collapse-item:last-child > .rc-collapse-content {\n  border-radius: 0 0 3px 3px;\n}\n.rc-collapse > .rc-collapse-item-active > .rc-collapse-header .arrow {\n  border-left: 3px solid transparent;\n  border-right: 3px solid transparent;\n  border-top: 4px solid #666;\n  margin-right: 6px;\n}\n", ""]);

// exports

/***/ }),
/* 844 */
/***/ (function(module, exports, __webpack_require__) {

var objectKeys = __webpack_require__(462);
var isArguments = __webpack_require__(956);
var is = __webpack_require__(1106);
var isRegex = __webpack_require__(959);
var flags = __webpack_require__(1440);
var isDate = __webpack_require__(957);

var getTime = Date.prototype.getTime;

function deepEqual(actual, expected, options) {
  var opts = options || {};

// 7.1. All identical values are equivalent, as determined by ===.
  if (opts.strict ? is(actual, expected) : actual === expected) {
    return true;
  }

// 7.3. Other pairs that do not both pass typeof value == 'object', equivalence is determined by ==.
  if (!actual || !expected || (typeof actual !== 'object' && typeof expected !== 'object')) {
    return opts.strict ? is(actual, expected) : actual == expected;
  }

/*
   * 7.4. For all other Object pairs, including Array objects, equivalence is
   * determined by having the same number of owned properties (as verified
   * with Object.prototype.hasOwnProperty.call), the same set of keys
   * (although not necessarily the same order), equivalent values for every
   * corresponding key, and an identical 'prototype' property. Note: this
   * accounts for both named and indexed properties on Arrays.
   */
  // eslint-disable-next-line no-use-before-define
  return objEquiv(actual, expected, opts);
}

function isUndefinedOrNull(value) {
  return value === null || value === undefined;
}

function objEquiv(a, b, opts) {
  /* eslint max-statements: [2, 50] */
  var i, key;
  if (typeof a !== typeof b) { return false; }
  if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) { return false; }

// an identical 'prototype' property.
  if (a.prototype !== b.prototype) { return false; }

if (isArguments(a) !== isArguments(b)) { return false; }

var aIsRegex = isRegex(a);
  var bIsRegex = isRegex(b);
  if (aIsRegex !== bIsRegex) { return false; }
  if (aIsRegex || bIsRegex) {
    return a.source === b.source && flags(a) === flags(b);
  }

if (isDate(a) && isDate(b)) {
    return getTime.call(a) === getTime.call(b);
  }

if (typeof a !== typeof b) { return false; }

try {
    var ka = objectKeys(a);
    var kb = objectKeys(b);
  } catch (e) { // happens when one is a string literal and the other isn't
    return false;
  }
  // having the same number of owned properties (keys incorporates hasOwnProperty)
  if (ka.length !== kb.length) { return false; }

// the same set of keys (although not necessarily the same order),
  ka.sort();
  kb.sort();
  // ~~~cheap key test
  for (i = ka.length - 1; i >= 0; i--) {
    if (ka[i] != kb[i]) { return false; }
  }
  // equivalent values for every corresponding key, and ~~~possibly expensive deep test
  for (i = ka.length - 1; i >= 0; i--) {
    key = ka[i];
    if (!deepEqual(a[key], b[key], opts)) { return false; }
  }

return true;
}

module.exports = deepEqual;

/***/ }),
/* 845 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
 * matchesSelector v2.0.2
 * matchesSelector( element, '.selector' )
 * MIT license
 */

/*jshint browser: true, strict: true, undef: true, unused: true */

( function( window, factory ) {
  /*global define: false, module: false */
  'use strict';
  // universal module definition
  if ( true ) {
    // AMD
    !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
				__WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if ( typeof module == 'object' && module.exports ) {
    // CommonJS
    module.exports = factory();
  } else {
    // browser global
    window.matchesSelector = factory();
  }

}( window, function factory() {
  'use strict';

var matchesMethod = ( function() {
    var ElemProto = window.Element.prototype;
    // check for the standard method name first
    if ( ElemProto.matches ) {
      return 'matches';
    }
    // check un-prefixed
    if ( ElemProto.matchesSelector ) {
      return 'matchesSelector';
    }
    // check vendor prefixes
    var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];

for ( var i=0; i < prefixes.length; i++ ) {
      var prefix = prefixes[i];
      var method = prefix + 'MatchesSelector';
      if ( ElemProto[ method ] ) {
        return method;
      }
    }
  })();

return function matchesSelector( elem, selector ) {
    return elem[ matchesMethod ]( selector );
  };

}));

/***/ }),
/* 846 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _isDisposable = __webpack_require__(262);

var _isDisposable2 = _interopRequireDefault(_isDisposable);

/**
 * Represents a group of disposable resources that are disposed together.
 */

var CompositeDisposable = (function () {
  function CompositeDisposable() {
    for (var _len = arguments.length, disposables = Array(_len), _key = 0; _key < _len; _key++) {
      disposables[_key] = arguments[_key];
    }

_classCallCheck(this, CompositeDisposable);

if (Array.isArray(disposables[0]) && disposables.length === 1) {
      disposables = disposables[0];
    }

for (var i = 0; i < disposables.length; i++) {
      if (!_isDisposable2['default'](disposables[i])) {
        throw new Error('Expected a disposable');
      }
    }

this.disposables = disposables;
    this.isDisposed = false;
  }

/**
   * Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed.
   * @param {Disposable} item Disposable to add.
   */

CompositeDisposable.prototype.add = function add(item) {
    if (this.isDisposed) {
      item.dispose();
    } else {
      this.disposables.push(item);
    }
  };

/**
   * Removes and disposes the first occurrence of a disposable from the CompositeDisposable.
   * @param {Disposable} item Disposable to remove.
   * @returns {Boolean} true if found; false otherwise.
   */

CompositeDisposable.prototype.remove = function remove(item) {
    if (this.isDisposed) {
      return false;
    }

var index = this.disposables.indexOf(item);
    if (index === -1) {
      return false;
    }

this.disposables.splice(index, 1);
    item.dispose();
    return true;
  };

/**
   * Disposes all disposables in the group and removes them from the group.
   */

CompositeDisposable.prototype.dispose = function dispose() {
    if (this.isDisposed) {
      return;
    }

var len = this.disposables.length;
    var currentDisposables = new Array(len);
    for (var i = 0; i < len; i++) {
      currentDisposables[i] = this.disposables[i];
    }

this.isDisposed = true;
    this.disposables = [];
    this.length = 0;

for (var i = 0; i < len; i++) {
      currentDisposables[i].dispose();
    }
  };

return CompositeDisposable;
})();

exports['default'] = CompositeDisposable;
module.exports = exports['default'];

/***/ }),
/* 847 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var noop = function noop() {};

/**
 * The basic disposable.
 */

var Disposable = (function () {
  _createClass(Disposable, null, [{
    key: "empty",
    value: { dispose: noop },
    enumerable: true
  }]);

function Disposable(action) {
    _classCallCheck(this, Disposable);

this.isDisposed = false;
    this.action = action || noop;
  }

Disposable.prototype.dispose = function dispose() {
    if (!this.isDisposed) {
      this.action.call(null);
      this.isDisposed = true;
    }
  };

return Disposable;
})();

exports["default"] = Disposable;
module.exports = exports["default"];

/***/ }),
/* 848 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _isDisposable = __webpack_require__(262);

var _isDisposable2 = _interopRequireDefault(_isDisposable);

var SerialDisposable = (function () {
  function SerialDisposable() {
    _classCallCheck(this, SerialDisposable);

this.isDisposed = false;
    this.current = null;
  }

/**
   * Gets the underlying disposable.
   * @return The underlying disposable.
   */

SerialDisposable.prototype.getDisposable = function getDisposable() {
    return this.current;
  };

/**
   * Sets the underlying disposable.
   * @param {Disposable} value The new underlying disposable.
   */

SerialDisposable.prototype.setDisposable = function setDisposable() {
    var value = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0];

if (value != null && !_isDisposable2['default'](value)) {
      throw new Error('Expected either an empty value or a valid disposable');
    }

var isDisposed = this.isDisposed;
    var previous = undefined;

if (!isDisposed) {
      previous = this.current;
      this.current = value;
    }

if (previous) {
      previous.dispose();
    }

if (isDisposed && value) {
      value.dispose();
    }
  };

/**
   * Disposes the underlying disposable as well as all future replacements.
   */

SerialDisposable.prototype.dispose = function dispose() {
    if (this.isDisposed) {
      return;
    }

this.isDisposed = true;
    var previous = this.current;
    this.current = null;

if (previous) {
      previous.dispose();
    }
  };

return SerialDisposable;
})();

exports['default'] = SerialDisposable;
module.exports = exports['default'];

/***/ }),
/* 849 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _isDisposable2 = __webpack_require__(262);

var _isDisposable3 = _interopRequireDefault(_isDisposable2);

exports.isDisposable = _isDisposable3['default'];

var _Disposable2 = __webpack_require__(847);

var _Disposable3 = _interopRequireDefault(_Disposable2);

exports.Disposable = _Disposable3['default'];

var _CompositeDisposable2 = __webpack_require__(846);

var _CompositeDisposable3 = _interopRequireDefault(_CompositeDisposable2);

exports.CompositeDisposable = _CompositeDisposable3['default'];

var _SerialDisposable2 = __webpack_require__(848);

var _SerialDisposable3 = _interopRequireDefault(_SerialDisposable2);

exports.SerialDisposable = _SerialDisposable3['default'];

/***/ }),
/* 850 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _createStore = __webpack_require__(862);

var _createStore2 = _interopRequireDefault(_createStore);

var _reducers = __webpack_require__(858);

var _reducers2 = _interopRequireDefault(_reducers);

var _dragDrop = __webpack_require__(165);

var dragDropActions = _interopRequireWildcard(_dragDrop);

var _DragDropMonitor = __webpack_require__(851);

var _DragDropMonitor2 = _interopRequireDefault(_DragDropMonitor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DragDropManager = function () {
	function DragDropManager(createBackend) {
		var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

_classCallCheck(this, DragDropManager);

var store = (0, _createStore2.default)(_reducers2.default);
		this.context = context;
		this.store = store;
		this.monitor = new _DragDropMonitor2.default(store);
		this.registry = this.monitor.registry;
		this.backend = createBackend(this);

store.subscribe(this.handleRefCountChange.bind(this));
	}

_createClass(DragDropManager, [{
		key: 'handleRefCountChange',
		value: function handleRefCountChange() {
			var shouldSetUp = this.store.getState().refCount > 0;
			if (shouldSetUp && !this.isSetUp) {
				this.backend.setup();
				this.isSetUp = true;
			} else if (!shouldSetUp && this.isSetUp) {
				this.backend.teardown();
				this.isSetUp = false;
			}
		}
	}, {
		key: 'getContext',
		value: function getContext() {
			return this.context;
		}
	}, {
		key: 'getMonitor',
		value: function getMonitor() {
			return this.monitor;
		}
	}, {
		key: 'getBackend',
		value: function getBackend() {
			return this.backend;
		}
	}, {
		key: 'getRegistry',
		value: function getRegistry() {
			return this.registry;
		}
	}, {
		key: 'getActions',
		value: function getActions() {
			var manager = this;
			var dispatch = this.store.dispatch;

function bindActionCreator(actionCreator) {
				return function () {
					for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
						args[_key] = arguments[_key];
					}

var action = actionCreator.apply(manager, args);
					if (typeof action !== 'undefined') {
						dispatch(action);
					}
				};
			}

return Object.keys(dragDropActions).filter(function (key) {
				return typeof dragDropActions[key] === 'function';
			}).reduce(function (boundActions, key) {
				var action = dragDropActions[key];
				boundActions[key] = bindActionCreator(action); // eslint-disable-line no-param-reassign
				return boundActions;
			}, {});
		}
	}]);

return DragDropManager;
}();

exports.default = DragDropManager;

/***/ }),
/* 851 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _isArray = __webpack_require__(27);

var _isArray2 = _interopRequireDefault(_isArray);

var _matchesType = __webpack_require__(401);

var _matchesType2 = _interopRequireDefault(_matchesType);

var _HandlerRegistry = __webpack_require__(854);

var _HandlerRegistry2 = _interopRequireDefault(_HandlerRegistry);

var _dragOffset = __webpack_require__(400);

var _dirtyHandlerIds = __webpack_require__(399);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DragDropMonitor = function () {
	function DragDropMonitor(store) {
		_classCallCheck(this, DragDropMonitor);

this.store = store;
		this.registry = new _HandlerRegistry2.default(store);
	}

_createClass(DragDropMonitor, [{
		key: 'subscribeToStateChange',
		value: function subscribeToStateChange(listener) {
			var _this = this;

var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
			var handlerIds = options.handlerIds;

(0, _invariant2.default)(typeof listener === 'function', 'listener must be a function.');
			(0, _invariant2.default)(typeof handlerIds === 'undefined' || (0, _isArray2.default)(handlerIds), 'handlerIds, when specified, must be an array of strings.');

var prevStateId = this.store.getState().stateId;
			var handleChange = function handleChange() {
				var state = _this.store.getState();
				var currentStateId = state.stateId;
				try {
					var canSkipListener = currentStateId === prevStateId || currentStateId === prevStateId + 1 && !(0, _dirtyHandlerIds.areDirty)(state.dirtyHandlerIds, handlerIds);

if (!canSkipListener) {
						listener();
					}
				} finally {
					prevStateId = currentStateId;
				}
			};

return this.store.subscribe(handleChange);
		}
	}, {
		key: 'subscribeToOffsetChange',
		value: function subscribeToOffsetChange(listener) {
			var _this2 = this;

(0, _invariant2.default)(typeof listener === 'function', 'listener must be a function.');

var previousState = this.store.getState().dragOffset;
			var handleChange = function handleChange() {
				var nextState = _this2.store.getState().dragOffset;
				if (nextState === previousState) {
					return;
				}

previousState = nextState;
				listener();
			};

return this.store.subscribe(handleChange);
		}
	}, {
		key: 'canDragSource',
		value: function canDragSource(sourceId) {
			var source = this.registry.getSource(sourceId);
			(0, _invariant2.default)(source, 'Expected to find a valid source.');

if (this.isDragging()) {
				return false;
			}

return source.canDrag(this, sourceId);
		}
	}, {
		key: 'canDropOnTarget',
		value: function canDropOnTarget(targetId) {
			var target = this.registry.getTarget(targetId);
			(0, _invariant2.default)(target, 'Expected to find a valid target.');

if (!this.isDragging() || this.didDrop()) {
				return false;
			}

if (!this.isDragging() || !this.isSourcePublic()) {
				return false;
			}

var sourceType = this.registry.getSourceType(sourceId);
			var draggedItemType = this.getItemType();
			if (sourceType !== draggedItemType) {
				return false;
			}

return source.isDragging(this, sourceId);
		}
	}, {
		key: 'isOverTarget',
		value: function isOverTarget(targetId) {
			var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { shallow: false };
			var shallow = options.shallow;

if (!this.isDragging()) {
				return false;
			}

var targetType = this.registry.getTargetType(targetId);
			var draggedItemType = this.getItemType();
			if (!(0, _matchesType2.default)(targetType, draggedItemType)) {
				return false;
			}

var targetIds = this.getTargetIds();
			if (!targetIds.length) {
				return false;
			}

return DragDropMonitor;
}();

exports.default = DragDropMonitor;

/***/ }),
/* 852 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DragSource = function () {
	function DragSource() {
		_classCallCheck(this, DragSource);
	}

_createClass(DragSource, [{
		key: "canDrag",
		value: function canDrag() {
			return true;
		}
	}, {
		key: "isDragging",
		value: function isDragging(monitor, handle) {
			return handle === monitor.getSourceId();
		}
	}, {
		key: "endDrag",
		value: function endDrag() {}
	}]);

return DragSource;
}();

exports.default = DragSource;

/***/ }),
/* 853 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DropTarget = function () {
	function DropTarget() {
		_classCallCheck(this, DropTarget);
	}

_createClass(DropTarget, [{
		key: "canDrop",
		value: function canDrop() {
			return true;
		}
	}, {
		key: "hover",
		value: function hover() {}
	}, {
		key: "drop",
		value: function drop() {}
	}]);

return DropTarget;
}();

exports.default = DropTarget;

/***/ }),
/* 854 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _isArray = __webpack_require__(27);

var _isArray2 = _interopRequireDefault(_isArray);

var _asap = __webpack_require__(628);

var _asap2 = _interopRequireDefault(_asap);

var _registry = __webpack_require__(166);

var _getNextUniqueId = __webpack_require__(861);

var _getNextUniqueId2 = _interopRequireDefault(_getNextUniqueId);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var HandlerRoles = {
	SOURCE: 'SOURCE',
	TARGET: 'TARGET'
};

function validateSourceContract(source) {
	(0, _invariant2.default)(typeof source.canDrag === 'function', 'Expected canDrag to be a function.');
	(0, _invariant2.default)(typeof source.beginDrag === 'function', 'Expected beginDrag to be a function.');
	(0, _invariant2.default)(typeof source.endDrag === 'function', 'Expected endDrag to be a function.');
}

function validateTargetContract(target) {
	(0, _invariant2.default)(typeof target.canDrop === 'function', 'Expected canDrop to be a function.');
	(0, _invariant2.default)(typeof target.hover === 'function', 'Expected hover to be a function.');
	(0, _invariant2.default)(typeof target.drop === 'function', 'Expected beginDrag to be a function.');
}

function validateType(type, allowArray) {
	if (allowArray && (0, _isArray2.default)(type)) {
		type.forEach(function (t) {
			return validateType(t, false);
		});
		return;
	}

(0, _invariant2.default)(typeof type === 'string' || (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'symbol', allowArray ? 'Type can only be a string, a symbol, or an array of either.' : 'Type can only be a string or a symbol.');
}

function getNextHandlerId(role) {
	var id = (0, _getNextUniqueId2.default)().toString();
	switch (role) {
		case HandlerRoles.SOURCE:
			return 'S' + id;
		case HandlerRoles.TARGET:
			return 'T' + id;
		default:
			(0, _invariant2.default)(false, 'Unknown role: ' + role);
	}
}

function parseRoleFromHandlerId(handlerId) {
	switch (handlerId[0]) {
		case 'S':
			return HandlerRoles.SOURCE;
		case 'T':
			return HandlerRoles.TARGET;
		default:
			(0, _invariant2.default)(false, 'Cannot parse handler ID: ' + handlerId);
	}
}

var HandlerRegistry = function () {
	function HandlerRegistry(store) {
		_classCallCheck(this, HandlerRegistry);

this.store = store;

this.types = {};
		this.handlers = {};

this.pinnedSourceId = null;
		this.pinnedSource = null;
	}

_createClass(HandlerRegistry, [{
		key: 'addSource',
		value: function addSource(type, source) {
			validateType(type);
			validateSourceContract(source);

var sourceId = this.addHandler(HandlerRoles.SOURCE, type, source);
			this.store.dispatch((0, _registry.addSource)(sourceId));
			return sourceId;
		}
	}, {
		key: 'addTarget',
		value: function addTarget(type, target) {
			validateType(type, true);
			validateTargetContract(target);

var targetId = this.addHandler(HandlerRoles.TARGET, type, target);
			this.store.dispatch((0, _registry.addTarget)(targetId));
			return targetId;
		}
	}, {
		key: 'addHandler',
		value: function addHandler(role, type, handler) {
			var id = getNextHandlerId(role);
			this.types[id] = type;
			this.handlers[id] = handler;

return id;
		}
	}, {
		key: 'containsHandler',
		value: function containsHandler(handler) {
			var _this = this;

return Object.keys(this.handlers).some(function (key) {
				return _this.handlers[key] === handler;
			});
		}
	}, {
		key: 'getSource',
		value: function getSource(sourceId, includePinned) {
			(0, _invariant2.default)(this.isSourceId(sourceId), 'Expected a valid source ID.');

var isPinned = includePinned && sourceId === this.pinnedSourceId;
			var source = isPinned ? this.pinnedSource : this.handlers[sourceId];

return source;
		}
	}, {
		key: 'getTarget',
		value: function getTarget(targetId) {
			(0, _invariant2.default)(this.isTargetId(targetId), 'Expected a valid target ID.');
			return this.handlers[targetId];
		}
	}, {
		key: 'getSourceType',
		value: function getSourceType(sourceId) {
			(0, _invariant2.default)(this.isSourceId(sourceId), 'Expected a valid source ID.');
			return this.types[sourceId];
		}
	}, {
		key: 'getTargetType',
		value: function getTargetType(targetId) {
			(0, _invariant2.default)(this.isTargetId(targetId), 'Expected a valid target ID.');
			return this.types[targetId];
		}
	}, {
		key: 'isSourceId',
		value: function isSourceId(handlerId) {
			var role = parseRoleFromHandlerId(handlerId);
			return role === HandlerRoles.SOURCE;
		}
	}, {
		key: 'isTargetId',
		value: function isTargetId(handlerId) {
			var role = parseRoleFromHandlerId(handlerId);
			return role === HandlerRoles.TARGET;
		}
	}, {
		key: 'removeSource',
		value: function removeSource(sourceId) {
			var _this2 = this;

(0, _invariant2.default)(this.getSource(sourceId), 'Expected an existing source.');
			this.store.dispatch((0, _registry.removeSource)(sourceId));

(0, _asap2.default)(function () {
				delete _this2.handlers[sourceId];
				delete _this2.types[sourceId];
			});
		}
	}, {
		key: 'removeTarget',
		value: function removeTarget(targetId) {
			var _this3 = this;

(0, _invariant2.default)(this.getTarget(targetId), 'Expected an existing target.');
			this.store.dispatch((0, _registry.removeTarget)(targetId));

(0, _asap2.default)(function () {
				delete _this3.handlers[targetId];
				delete _this3.types[targetId];
			});
		}
	}, {
		key: 'pinSource',
		value: function pinSource(sourceId) {
			var source = this.getSource(sourceId);
			(0, _invariant2.default)(source, 'Expected an existing source.');

this.pinnedSourceId = sourceId;
			this.pinnedSource = source;
		}
	}, {
		key: 'unpinSource',
		value: function unpinSource() {
			(0, _invariant2.default)(this.pinnedSource, 'No source is pinned at the time.');

this.pinnedSourceId = null;
			this.pinnedSource = null;
		}
	}]);

return HandlerRegistry;
}();

exports.default = HandlerRegistry;

/***/ }),
/* 855 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

exports.default = createBackend;

var _noop = __webpack_require__(295);

var _noop2 = _interopRequireDefault(_noop);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var TestBackend = function () {
	function TestBackend(manager) {
		_classCallCheck(this, TestBackend);

this.actions = manager.getActions();
	}

_createClass(TestBackend, [{
		key: 'setup',
		value: function setup() {
			this.didCallSetup = true;
		}
	}, {
		key: 'teardown',
		value: function teardown() {
			this.didCallTeardown = true;
		}
	}, {
		key: 'connectDragSource',
		value: function connectDragSource() {
			return _noop2.default;
		}
	}, {
		key: 'connectDragPreview',
		value: function connectDragPreview() {
			return _noop2.default;
		}
	}, {
		key: 'connectDropTarget',
		value: function connectDropTarget() {
			return _noop2.default;
		}
	}, {
		key: 'simulateBeginDrag',
		value: function simulateBeginDrag(sourceIds, options) {
			this.actions.beginDrag(sourceIds, options);
		}
	}, {
		key: 'simulatePublishDragSource',
		value: function simulatePublishDragSource() {
			this.actions.publishDragSource();
		}
	}, {
		key: 'simulateHover',
		value: function simulateHover(targetIds, options) {
			this.actions.hover(targetIds, options);
		}
	}, {
		key: 'simulateDrop',
		value: function simulateDrop() {
			this.actions.drop();
		}
	}, {
		key: 'simulateEndDrag',
		value: function simulateEndDrag() {
			this.actions.endDrag();
		}
	}]);

return TestBackend;
}();

function createBackend(manager) {
	return new TestBackend(manager);
}

/***/ }),
/* 856 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _DragDropManager = __webpack_require__(850);

Object.defineProperty(exports, 'DragDropManager', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_DragDropManager).default;
  }
});

var _DragSource = __webpack_require__(852);

Object.defineProperty(exports, 'DragSource', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_DragSource).default;
  }
});

var _DropTarget = __webpack_require__(853);

Object.defineProperty(exports, 'DropTarget', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_DropTarget).default;
  }
});

var _createTestBackend = __webpack_require__(855);

Object.defineProperty(exports, 'createTestBackend', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_createTestBackend).default;
  }
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ }),
/* 857 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});

exports.default = dragOperation;

var _without = __webpack_require__(457);

var _without2 = _interopRequireDefault(_without);

var _dragDrop = __webpack_require__(165);

var _registry = __webpack_require__(166);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var initialState = {
	itemType: null,
	item: null,
	sourceId: null,
	targetIds: [],
	dropResult: null,
	didDrop: false,
	isSourcePublic: null
};

function dragOperation() {
	var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
	var action = arguments[1];

switch (action.type) {
		case _dragDrop.BEGIN_DRAG:
			return _extends({}, state, {
				itemType: action.itemType,
				item: action.item,
				sourceId: action.sourceId,
				isSourcePublic: action.isSourcePublic,
				dropResult: null,
				didDrop: false
			});
		case _dragDrop.PUBLISH_DRAG_SOURCE:
			return _extends({}, state, {
				isSourcePublic: true
			});
		case _dragDrop.HOVER:
			return _extends({}, state, {
				targetIds: action.targetIds
			});
		case _registry.REMOVE_TARGET:
			if (state.targetIds.indexOf(action.targetId) === -1) {
				return state;
			}
			return _extends({}, state, {
				targetIds: (0, _without2.default)(state.targetIds, action.targetId)
			});
		case _dragDrop.DROP:
			return _extends({}, state, {
				dropResult: action.dropResult,
				didDrop: true,
				targetIds: []
			});
		case _dragDrop.END_DRAG:
			return _extends({}, state, {
				itemType: null,
				item: null,
				sourceId: null,
				dropResult: null,
				didDrop: false,
				isSourcePublic: null,
				targetIds: []
			});
		default:
			return state;
	}
}

/***/ }),
/* 858 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.default = reduce;

var _dragOffset = __webpack_require__(400);

var _dragOffset2 = _interopRequireDefault(_dragOffset);

var _dragOperation = __webpack_require__(857);

var _dragOperation2 = _interopRequireDefault(_dragOperation);

var _refCount = __webpack_require__(859);

var _refCount2 = _interopRequireDefault(_refCount);

var _dirtyHandlerIds = __webpack_require__(399);

var _dirtyHandlerIds2 = _interopRequireDefault(_dirtyHandlerIds);

var _stateId = __webpack_require__(860);

var _stateId2 = _interopRequireDefault(_stateId);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function reduce() {
	var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	var action = arguments[1];

return {
		dirtyHandlerIds: (0, _dirtyHandlerIds2.default)(state.dirtyHandlerIds, action, state.dragOperation),
		dragOffset: (0, _dragOffset2.default)(state.dragOffset, action),
		refCount: (0, _refCount2.default)(state.refCount, action),
		dragOperation: (0, _dragOperation2.default)(state.dragOperation, action),
		stateId: (0, _stateId2.default)(state.stateId)
	};
}

/***/ }),
/* 859 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.default = refCount;

var _registry = __webpack_require__(166);

function refCount() {
	var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
	var action = arguments[1];

switch (action.type) {
		case _registry.ADD_SOURCE:
		case _registry.ADD_TARGET:
			return state + 1;
		case _registry.REMOVE_SOURCE:
		case _registry.REMOVE_TARGET:
			return state - 1;
		default:
			return state;
	}
}

/***/ }),
/* 860 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.default = stateId;
function stateId() {
	var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;

return state + 1;
}

/***/ }),
/* 861 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.default = getNextUniqueId;
var nextUniqueId = 0;

function getNextUniqueId() {
	return nextUniqueId++;
}

/***/ }),
/* 862 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.ActionTypes = undefined;
exports['default'] = createStore;

var _isPlainObject = __webpack_require__(48);

var _isPlainObject2 = _interopRequireDefault(_isPlainObject);

var _symbolObservable = __webpack_require__(1456);

var _symbolObservable2 = _interopRequireDefault(_symbolObservable);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

/**
   * Creates a Redux store that holds the state tree.
   * The only way to change the data in the store is to call `dispatch()` on it.
   *
   * There should only be a single store in your app. To specify how different
   * parts of the state tree respond to actions, you may combine several reducers
   * into a single reducer function by using `combineReducers`.
   *
   * @param {Function} reducer A function that returns the next state tree, given
   * the current state tree and the action to handle.
   *
   * @param {any} [preloadedState] The initial state. You may optionally specify it
   * to hydrate the state from the server in universal apps, or to restore a
   * previously serialized user session.
   * If you use `combineReducers` to produce the root reducer function, this must be
   * an object with the same shape as `combineReducers` keys.
   *
   * @param {Function} [enhancer] The store enhancer. You may optionally specify it
   * to enhance the store with third-party capabilities such as middleware,
   * time travel, persistence, etc. The only store enhancer that ships with Redux
   * is `applyMiddleware()`.
   *
   * @returns {Store} A Redux store that lets you read the state, dispatch actions
   * and subscribe to changes.
   */
};function createStore(reducer, preloadedState, enhancer) {
  var _ref2;

if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
    enhancer = preloadedState;
    preloadedState = undefined;
  }

if (typeof enhancer !== 'undefined') {
    if (typeof enhancer !== 'function') {
      throw new Error('Expected the enhancer to be a function.');
    }

return enhancer(createStore)(reducer, preloadedState);
  }

if (typeof reducer !== 'function') {
    throw new Error('Expected the reducer to be a function.');
  }

var currentReducer = reducer;
  var currentState = preloadedState;
  var currentListeners = [];
  var nextListeners = currentListeners;
  var isDispatching = false;

function ensureCanMutateNextListeners() {
    if (nextListeners === currentListeners) {
      nextListeners = currentListeners.slice();
    }
  }

/**
   * Reads the state tree managed by the store.
   *
   * @returns {any} The current state tree of your application.
   */
  function getState() {
    return currentState;
  }

var isSubscribed = true;

ensureCanMutateNextListeners();
    nextListeners.push(listener);

return function unsubscribe() {
      if (!isSubscribed) {
        return;
      }

isSubscribed = false;

ensureCanMutateNextListeners();
      var index = nextListeners.indexOf(listener);
      nextListeners.splice(index, 1);
    };
  }

/**
   * Dispatches an action. It is the only way to trigger a state change.
   *
   * The `reducer` function, used to create the store, will be called with the
   * current state tree and the given `action`. Its return value will
   * be considered the **next** state of the tree, and the change listeners
   * will be notified.
   *
   * The base implementation only supports plain object actions. If you want to
   * dispatch a Promise, an Observable, a thunk, or something else, you need to
   * wrap your store creating function into the corresponding middleware. For
   * example, see the documentation for the `redux-thunk` package. Even the
   * middleware will eventually dispatch plain object actions using this method.
   *
   * @param {Object} action A plain object representing “what changed”. It is
   * a good idea to keep actions serializable so you can record and replay user
   * sessions, or use the time travelling `redux-devtools`. An action must have
   * a `type` property which may not be `undefined`. It is a good idea to use
   * string constants for action types.
   *
   * @returns {Object} For convenience, the same action object you dispatched.
   *
   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
   * return something else (for example, a Promise you can await).
   */
  function dispatch(action) {
    if (!(0, _isPlainObject2['default'])(action)) {
      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
    }

if (typeof action.type === 'undefined') {
      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
    }

if (isDispatching) {
      throw new Error('Reducers may not dispatch actions.');
    }

try {
      isDispatching = true;
      currentState = currentReducer(currentState, action);
    } finally {
      isDispatching = false;
    }

var listeners = currentListeners = nextListeners;
    for (var i = 0; i < listeners.length; i++) {
      var listener = listeners[i];
      listener();
    }

return action;
  }

currentReducer = nextReducer;
    dispatch({ type: ActionTypes.INIT });
  }

/**
   * Interoperability point for observable/reactive libraries.
   * @returns {observable} A minimal observable of state changes.
   * For more information, see the observable proposal:
   * https://github.com/tc39/proposal-observable
   */
  function observable() {
    var _ref;

function observeState() {
          if (observer.next) {
            observer.next(getState());
          }
        }

observeState();
        var unsubscribe = outerSubscribe(observeState);
        return { unsubscribe: unsubscribe };
      }
    }, _ref[_symbolObservable2['default']] = function () {
      return this;
    }, _ref;
  }

return _ref2 = {
    dispatch: dispatch,
    subscribe: subscribe,
    getState: getState,
    replaceReducer: replaceReducer
  }, _ref2[_symbolObservable2['default']] = observable, _ref2;
}

/***/ }),
/* 863 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return alignElement; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return alignPoint; });
function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);

if (enumerableOnly) {
      symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
    }

keys.push.apply(keys, symbols);
  }

return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

return target;
}

function _typeof(obj) {
  "@babel/helpers - typeof";

if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

return _typeof(obj);
}

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

return obj;
}

var vendorPrefix;
var jsCssMap = {
  Webkit: '-webkit-',
  Moz: '-moz-',
  // IE did it wrong again ...
  ms: '-ms-',
  O: '-o-'
};

function getVendorPrefix() {
  if (vendorPrefix !== undefined) {
    return vendorPrefix;
  }

vendorPrefix = '';
  var style = document.createElement('p').style;
  var testProp = 'Transform';

for (var key in jsCssMap) {
    if (key + testProp in style) {
      vendorPrefix = key;
    }
  }

return vendorPrefix;
}

function getTransitionName() {
  return getVendorPrefix() ? "".concat(getVendorPrefix(), "TransitionProperty") : 'transitionProperty';
}

function getTransformName() {
  return getVendorPrefix() ? "".concat(getVendorPrefix(), "Transform") : 'transform';
}
function setTransitionProperty(node, value) {
  var name = getTransitionName();

if (name) {
    node.style[name] = value;

if (name !== 'transitionProperty') {
      node.style.transitionProperty = value;
    }
  }
}

function setTransform(node, value) {
  var name = getTransformName();

if (name) {
    node.style[name] = value;

if (name !== 'transform') {
      node.style.transform = value;
    }
  }
}

function getTransitionProperty(node) {
  return node.style.transitionProperty || node.style[getTransitionName()];
}
function getTransformXY(node) {
  var style = window.getComputedStyle(node, null);
  var transform = style.getPropertyValue('transform') || style.getPropertyValue(getTransformName());

if (transform && transform !== 'none') {
    var matrix = transform.replace(/[^0-9\-.,]/g, '').split(',');
    return {
      x: parseFloat(matrix[12] || matrix[4], 0),
      y: parseFloat(matrix[13] || matrix[5], 0)
    };
  }

return {
    x: 0,
    y: 0
  };
}
var matrix2d = /matrix$(.*)$/;
var matrix3d = /matrix3d$(.*)$/;
function setTransformXY(node, xy) {
  var style = window.getComputedStyle(node, null);
  var transform = style.getPropertyValue('transform') || style.getPropertyValue(getTransformName());

if (transform && transform !== 'none') {
    var arr;
    var match2d = transform.match(matrix2d);

if (match2d) {
      match2d = match2d[1];
      arr = match2d.split(',').map(function (item) {
        return parseFloat(item, 10);
      });
      arr[4] = xy.x;
      arr[5] = xy.y;
      setTransform(node, "matrix(".concat(arr.join(','), ")"));
    } else {
      var match3d = transform.match(matrix3d)[1];
      arr = match3d.split(',').map(function (item) {
        return parseFloat(item, 10);
      });
      arr[12] = xy.x;
      arr[13] = xy.y;
      setTransform(node, "matrix3d(".concat(arr.join(','), ")"));
    }
  } else {
    setTransform(node, "translateX(".concat(xy.x, "px) translateY(").concat(xy.y, "px) translateZ(0)"));
  }
}

var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source;
var getComputedStyleX; // https://stackoverflow.com/a/3485654/3040605

function forceRelayout(elem) {
  var originalStyle = elem.style.display;
  elem.style.display = 'none';
  elem.offsetHeight; // eslint-disable-line

elem.style.display = originalStyle;
}

function css(el, name, v) {
  var value = v;

if (_typeof(name) === 'object') {
    for (var i in name) {
      if (name.hasOwnProperty(i)) {
        css(el, i, name[i]);
      }
    }

return undefined;
  }

if (typeof value !== 'undefined') {
    if (typeof value === 'number') {
      value = "".concat(value, "px");
    }

el.style[name] = value;
    return undefined;
  }

return getComputedStyleX(el, name);
}

function getClientPosition(elem) {
  var box;
  var x;
  var y;
  var doc = elem.ownerDocument;
  var body = doc.body;
  var docElem = doc && doc.documentElement; // 根据 GBS 最新数据，A-Grade Browsers 都已支持 getBoundingClientRect 方法，不用再考虑传统的实现方式

box = elem.getBoundingClientRect(); // 注：jQuery 还考虑减去 docElem.clientLeft/clientTop
  // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确
  // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin

x = Math.floor(box.left);
  y = Math.floor(box.top); // In IE, most of the time, 2 extra pixels are added to the top and left
  // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
  // IE6 standards mode, this border can be overridden by setting the
  // document element's border to zero -- thus, we cannot rely on the
  // offset always being 2 pixels.
  // In quirks mode, the offset can be determined by querying the body's
  // clientLeft/clientTop, but in standards mode, it is found by querying
  // the document element's clientLeft/clientTop.  Since we already called
  // getClientBoundingRect we have already forced a reflow, so it is not
  // too expensive just to query them all.
  // ie 下应该减去窗口的边框吧，毕竟默认 absolute 都是相对窗口定位的
  // 窗口边框标准是设 documentElement ,quirks 时设置 body
  // 最好禁止在 body 和 html 上边框 ，但 ie < 9 html 默认有 2px ，减去
  // 但是非 ie 不可能设置窗口边框，body html 也不是窗口 ,ie 可以通过 html,body 设置
  // 标准 ie 下 docElem.clientTop 就是 border-top
  // ie7 html 即窗口边框改变不了。永远为 2
  // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框，即使设了 border-top 也为 0

x -= docElem.clientLeft || body.clientLeft || 0;
  y -= docElem.clientTop || body.clientTop || 0;
  return {
    left: x,
    top: y
  };
}

function getScroll(w, top) {
  var ret = w["page".concat(top ? 'Y' : 'X', "Offset")];
  var method = "scroll".concat(top ? 'Top' : 'Left');

if (typeof ret !== 'number') {
    var d = w.document; // ie6,7,8 standard mode

ret = d.documentElement[method];

if (typeof ret !== 'number') {
      // quirks mode
      ret = d.body[method];
    }
  }

return ret;
}

function getScrollLeft(w) {
  return getScroll(w);
}

function getScrollTop(w) {
  return getScroll(w, true);
}

function getOffset(el) {
  var pos = getClientPosition(el);
  var doc = el.ownerDocument;
  var w = doc.defaultView || doc.parentWindow;
  pos.left += getScrollLeft(w);
  pos.top += getScrollTop(w);
  return pos;
}
/**
 * A crude way of determining if an object is a window
 * @member util
 */

function isWindow(obj) {
  // must use == for ie8

/* eslint eqeqeq:0 */
  return obj !== null && obj !== undefined && obj == obj.window;
}

function getDocument(node) {
  if (isWindow(node)) {
    return node.document;
  }

if (node.nodeType === 9) {
    return node;
  }

return node.ownerDocument;
}

function _getComputedStyle(elem, name, cs) {
  var computedStyle = cs;
  var val = '';
  var d = getDocument(elem);
  computedStyle = computedStyle || d.defaultView.getComputedStyle(elem, null); // https://github.com/kissyteam/kissy/issues/61

if (computedStyle) {
    val = computedStyle.getPropertyValue(name) || computedStyle[name];
  }

return val;
}

var _RE_NUM_NO_PX = new RegExp("^(".concat(RE_NUM, ")(?!px)[a-z%]+$"), 'i');

var RE_POS = /^(top|right|bottom|left)$/;
var CURRENT_STYLE = 'currentStyle';
var RUNTIME_STYLE = 'runtimeStyle';
var LEFT = 'left';
var PX = 'px';

function _getComputedStyleIE(elem, name) {
  // currentStyle maybe null
  // http://msdn.microsoft.com/en-us/library/ms535231.aspx
  var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name]; // 当 width/height 设置为百分比时，通过 pixelLeft 方式转换的 width/height 值
  // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19
  // 在 ie 下不对，需要直接用 offset 方式
  // borderWidth 等值也有问题，但考虑到 borderWidth 设为百分比的概率很小，这里就不考虑了
  // From the awesome hack by Dean Edwards
  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
  // If we're not dealing with a regular pixel number
  // but a number that has a weird ending, we need to convert it to pixels
  // exclude left right for relativity

if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {
    // Remember the original values
    var style = elem.style;
    var left = style[LEFT];
    var rsLeft = elem[RUNTIME_STYLE][LEFT]; // prevent flashing of content

elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT]; // Put in the new values to get a computed value out

style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;
    ret = style.pixelLeft + PX; // Revert the changed values

style[LEFT] = left;
    elem[RUNTIME_STYLE][LEFT] = rsLeft;
  }

return ret === '' ? 'auto' : ret;
}

if (typeof window !== 'undefined') {
  getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;
}

function getOffsetDirection(dir, option) {
  if (dir === 'left') {
    return option.useCssRight ? 'right' : dir;
  }

return option.useCssBottom ? 'bottom' : dir;
}

function setLeftTop(elem, offset, option) {
  // set position first, in-case top/left are set even on static elem
  if (css(elem, 'position') === 'static') {
    elem.style.position = 'relative';
  }

var presetH = -999;
  var presetV = -999;
  var horizontalProperty = getOffsetDirection('left', option);
  var verticalProperty = getOffsetDirection('top', option);
  var oppositeHorizontalProperty = oppositeOffsetDirection(horizontalProperty);
  var oppositeVerticalProperty = oppositeOffsetDirection(verticalProperty);

if (horizontalProperty !== 'left') {
    presetH = 999;
  }

if (verticalProperty !== 'top') {
    presetV = 999;
  }

var originalTransition = '';
  var originalOffset = getOffset(elem);

if ('left' in offset || 'top' in offset) {
    originalTransition = getTransitionProperty(elem) || '';
    setTransitionProperty(elem, 'none');
  }

if ('left' in offset) {
    elem.style[oppositeHorizontalProperty] = '';
    elem.style[horizontalProperty] = "".concat(presetH, "px");
  }

if ('top' in offset) {
    elem.style[oppositeVerticalProperty] = '';
    elem.style[verticalProperty] = "".concat(presetV, "px");
  } // force relayout

forceRelayout(elem);
  var old = getOffset(elem);
  var originalStyle = {};

for (var key in offset) {
    if (offset.hasOwnProperty(key)) {
      var dir = getOffsetDirection(key, option);
      var preset = key === 'left' ? presetH : presetV;
      var off = originalOffset[key] - old[key];

if (dir === key) {
        originalStyle[dir] = preset + off;
      } else {
        originalStyle[dir] = preset - off;
      }
    }
  }

css(elem, originalStyle); // force relayout

forceRelayout(elem);

if ('left' in offset || 'top' in offset) {
    setTransitionProperty(elem, originalTransition);
  }

var ret = {};

for (var _key in offset) {
    if (offset.hasOwnProperty(_key)) {
      var _dir = getOffsetDirection(_key, option);

var _off = offset[_key] - originalOffset[_key];

if (_key === _dir) {
        ret[_dir] = originalStyle[_dir] + _off;
      } else {
        ret[_dir] = originalStyle[_dir] - _off;
      }
    }
  }

css(elem, ret);
}

function setTransform$1(elem, offset) {
  var originalOffset = getOffset(elem);
  var originalXY = getTransformXY(elem);
  var resultXY = {
    x: originalXY.x,
    y: originalXY.y
  };

if ('left' in offset) {
    resultXY.x = originalXY.x + offset.left - originalOffset.left;
  }

if ('top' in offset) {
    resultXY.y = originalXY.y + offset.top - originalOffset.top;
  }

setTransformXY(elem, resultXY);
}

function setOffset(elem, offset, option) {
  if (option.ignoreShake) {
    var oriOffset = getOffset(elem);
    var oLeft = oriOffset.left.toFixed(0);
    var oTop = oriOffset.top.toFixed(0);
    var tLeft = offset.left.toFixed(0);
    var tTop = offset.top.toFixed(0);

if (oLeft === tLeft && oTop === tTop) {
      return;
    }
  }

if (option.useCssRight || option.useCssBottom) {
    setLeftTop(elem, offset, option);
  } else if (option.useCssTransform && getTransformName() in document.body.style) {
    setTransform$1(elem, offset);
  } else {
    setLeftTop(elem, offset, option);
  }
}

function each(arr, fn) {
  for (var i = 0; i < arr.length; i++) {
    fn(arr[i]);
  }
}

function isBorderBoxFn(elem) {
  return getComputedStyleX(elem, 'boxSizing') === 'border-box';
}

var BOX_MODELS = ['margin', 'border', 'padding'];
var CONTENT_INDEX = -1;
var PADDING_INDEX = 2;
var BORDER_INDEX = 1;
var MARGIN_INDEX = 0;

function swap(elem, options, callback) {
  var old = {};
  var style = elem.style;
  var name; // Remember the old values, and insert the new ones

for (name in options) {
    if (options.hasOwnProperty(name)) {
      old[name] = style[name];
      style[name] = options[name];
    }
  }

callback.call(elem); // Revert the old values

for (name in options) {
    if (options.hasOwnProperty(name)) {
      style[name] = old[name];
    }
  }
}

function getPBMWidth(elem, props, which) {
  var value = 0;
  var prop;
  var j;
  var i;

for (j = 0; j < props.length; j++) {
    prop = props[j];

if (prop) {
      for (i = 0; i < which.length; i++) {
        var cssProp = void 0;

if (prop === 'border') {
          cssProp = "".concat(prop).concat(which[i], "Width");
        } else {
          cssProp = prop + which[i];
        }

value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
      }
    }
  }

return value;
}

var domUtils = {
  getParent: function getParent(element) {
    var parent = element;

do {
      if (parent.nodeType === 11 && parent.host) {
        parent = parent.host;
      } else {
        parent = parent.parentNode;
      }
    } while (parent && parent.nodeType !== 1 && parent.nodeType !== 9);

return parent;
  }
};
each(['Width', 'Height'], function (name) {
  domUtils["doc".concat(name)] = function (refWin) {
    var d = refWin.document;
    return Math.max( // firefox chrome documentElement.scrollHeight< body.scrollHeight
    // ie standard mode : documentElement.scrollHeight> body.scrollHeight
    d.documentElement["scroll".concat(name)], // quirks : documentElement.scrollHeight 最大等于可视窗口多一点？
    d.body["scroll".concat(name)], domUtils["viewport".concat(name)](d));
  };

domUtils["viewport".concat(name)] = function (win) {
    // pc browser includes scrollbar in window.innerWidth
    var prop = "client".concat(name);
    var doc = win.document;
    var body = doc.body;
    var documentElement = doc.documentElement;
    var documentElementProp = documentElement[prop]; // 标准模式取 documentElement
    // backcompat 取 body

return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;
  };
});
/*
 得到元素的大小信息
 @param elem
 @param name
 @param {String} [extra]  'padding' : (css width) + padding
 'border' : (css width) + padding + border
 'margin' : (css width) + padding + border + margin
 */

function getWH(elem, name, ex) {
  var extra = ex;

if (isWindow(elem)) {
    return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
  } else if (elem.nodeType === 9) {
    return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
  }

var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
  var borderBoxValue = name === 'width' ? Math.floor(elem.getBoundingClientRect().width) : Math.floor(elem.getBoundingClientRect().height);
  var isBorderBox = isBorderBoxFn(elem);
  var cssBoxValue = 0;

if (borderBoxValue === null || borderBoxValue === undefined || borderBoxValue <= 0) {
    borderBoxValue = undefined; // Fall back to computed then un computed css if necessary

cssBoxValue = getComputedStyleX(elem, name);

if (cssBoxValue === null || cssBoxValue === undefined || Number(cssBoxValue) < 0) {
      cssBoxValue = elem.style[name] || 0;
    } // Normalize '', auto, and prepare for extra

cssBoxValue = parseFloat(cssBoxValue) || 0;
  }

if (extra === undefined) {
    extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
  }

var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;
  var val = borderBoxValue || cssBoxValue;

if (extra === CONTENT_INDEX) {
    if (borderBoxValueOrIsBorderBox) {
      return val - getPBMWidth(elem, ['border', 'padding'], which);
    }

return cssBoxValue;
  } else if (borderBoxValueOrIsBorderBox) {
    if (extra === BORDER_INDEX) {
      return val;
    }

return val + (extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which) : getPBMWidth(elem, ['margin'], which));
  }

return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which);
}

var cssShow = {
  position: 'absolute',
  visibility: 'hidden',
  display: 'block'
}; // fix #119 : https://github.com/kissyteam/kissy/issues/119

function getWHIgnoreDisplay() {
  for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
    args[_key2] = arguments[_key2];
  }

var val;
  var elem = args[0]; // in case elem is window
  // elem.offsetWidth === undefined

if (elem.offsetWidth !== 0) {
    val = getWH.apply(undefined, args);
  } else {
    swap(elem, cssShow, function () {
      val = getWH.apply(undefined, args);
    });
  }

return val;
}

each(['width', 'height'], function (name) {
  var first = name.charAt(0).toUpperCase() + name.slice(1);

domUtils["outer".concat(first)] = function (el, includeMargin) {
    return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
  };

var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];

domUtils[name] = function (elem, v) {
    var val = v;

if (val !== undefined) {
      if (elem) {
        var isBorderBox = isBorderBoxFn(elem);

if (isBorderBox) {
          val += getPBMWidth(elem, ['padding', 'border'], which);
        }

return css(elem, name, val);
      }

return undefined;
    }

return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
  };
});

function mix(to, from) {
  for (var i in from) {
    if (from.hasOwnProperty(i)) {
      to[i] = from[i];
    }
  }

return to;
}

var utils = {
  getWindow: function getWindow(node) {
    if (node && node.document && node.setTimeout) {
      return node;
    }

for (i in obj) {
      if (obj.hasOwnProperty(i)) {
        ret[i] = obj[i];
      }
    }

var overflow = obj.overflow;

if (overflow) {
      for (i in obj) {
        if (obj.hasOwnProperty(i)) {
          ret.overflow[i] = obj.overflow[i];
        }
      }
    }

return ret;
  },
  mix: mix,
  getWindowScrollLeft: function getWindowScrollLeft(w) {
    return getScrollLeft(w);
  },
  getWindowScrollTop: function getWindowScrollTop(w) {
    return getScrollTop(w);
  },
  merge: function merge() {
    var ret = {};

for (var i = 0; i < arguments.length; i++) {
      utils.mix(ret, i < 0 || arguments.length <= i ? undefined : arguments[i]);
    }

return ret;
  },
  viewportWidth: 0,
  viewportHeight: 0
};
mix(utils, domUtils);

/**
 * 得到会导致元素显示不全的祖先元素
 */

var getParent = utils.getParent;

function getOffsetParent(element) {
  if (utils.isWindow(element) || element.nodeType === 9) {
    return null;
  } // ie 这个也不是完全可行

/*
   <div style="width: 50px;height: 100px;overflow: hidden">
   <div style="width: 50px;height: 100px;position: relative;" id="d6">
   元素 6 高 100px 宽 50px<br/>
   </div>
   </div>
   */
  // element.offsetParent does the right thing in ie7 and below. Return parent with layout!
  //  In other browsers it only includes elements with position absolute, relative or
  // fixed, not elements with overflow set to auto or scroll.
  //        if (UA.ie && ieMode < 8) {
  //            return element.offsetParent;
  //        }
  // 统一的 offsetParent 方法

var doc = utils.getDocument(element);
  var body = doc.body;
  var parent;
  var positionStyle = utils.css(element, 'position');
  var skipStatic = positionStyle === 'fixed' || positionStyle === 'absolute';

if (!skipStatic) {
    return element.nodeName.toLowerCase() === 'html' ? null : getParent(element);
  }

for (parent = getParent(element); parent && parent !== body && parent.nodeType !== 9; parent = getParent(parent)) {
    positionStyle = utils.css(parent, 'position');

if (positionStyle !== 'static') {
      return parent;
    }
  }

return null;
}

var getParent$1 = utils.getParent;
function isAncestorFixed(element) {
  if (utils.isWindow(element) || element.nodeType === 9) {
    return false;
  }

var doc = utils.getDocument(element);
  var body = doc.body;
  var parent = null;

for (parent = getParent$1(element); // 修复元素位于 document.documentElement 下导致崩溃问题
  parent && parent !== body && parent !== doc; parent = getParent$1(parent)) {
    var positionStyle = utils.css(parent, 'position');

if (positionStyle === 'fixed') {
      return true;
    }
  }

return false;
}

/**
 * 获得元素的显示部分的区域
 */

function getVisibleRectForElement(element, alwaysByViewport) {
  var visibleRect = {
    left: 0,
    right: Infinity,
    top: 0,
    bottom: Infinity
  };
  var el = getOffsetParent(element);
  var doc = utils.getDocument(element);
  var win = doc.defaultView || doc.parentWindow;
  var body = doc.body;
  var documentElement = doc.documentElement; // Determine the size of the visible rect by climbing the dom accounting for
  // all scrollable containers.

while (el) {
    // clientWidth is zero for inline block elements in ie.
    if ((navigator.userAgent.indexOf('MSIE') === -1 || el.clientWidth !== 0) && // body may have overflow set on it, yet we still get the entire
    // viewport. In some browsers, el.offsetParent may be
    // document.documentElement, so check for that too.
    el !== body && el !== documentElement && utils.css(el, 'overflow') !== 'visible') {
      var pos = utils.offset(el); // add border

pos.left += el.clientLeft;
      pos.top += el.clientTop;
      visibleRect.top = Math.max(visibleRect.top, pos.top);
      visibleRect.right = Math.min(visibleRect.right, // consider area without scrollBar
      pos.left + el.clientWidth);
      visibleRect.bottom = Math.min(visibleRect.bottom, pos.top + el.clientHeight);
      visibleRect.left = Math.max(visibleRect.left, pos.left);
    } else if (el === body || el === documentElement) {
      break;
    }

el = getOffsetParent(el);
  } // Set element position to fixed
  // make sure absolute element itself don't affect it's visible area
  // https://github.com/ant-design/ant-design/issues/7601

var originalPosition = null;

if (!utils.isWindow(element) && element.nodeType !== 9) {
    originalPosition = element.style.position;
    var position = utils.css(element, 'position');

if (position === 'absolute') {
      element.style.position = 'fixed';
    }
  }

var scrollX = utils.getWindowScrollLeft(win);
  var scrollY = utils.getWindowScrollTop(win);
  var viewportWidth = utils.viewportWidth(win);
  var viewportHeight = utils.viewportHeight(win);
  var documentWidth = documentElement.scrollWidth;
  var documentHeight = documentElement.scrollHeight; // scrollXXX on html is sync with body which means overflow: hidden on body gets wrong scrollXXX.
  // We should cut this ourself.

var bodyStyle = window.getComputedStyle(body);

if (bodyStyle.overflowX === 'hidden') {
    documentWidth = win.innerWidth;
  }

if (bodyStyle.overflowY === 'hidden') {
    documentHeight = win.innerHeight;
  } // Reset element position after calculate the visible area

if (element.style) {
    element.style.position = originalPosition;
  }

if (alwaysByViewport || isAncestorFixed(element)) {
    // Clip by viewport's size.
    visibleRect.left = Math.max(visibleRect.left, scrollX);
    visibleRect.top = Math.max(visibleRect.top, scrollY);
    visibleRect.right = Math.min(visibleRect.right, scrollX + viewportWidth);
    visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + viewportHeight);
  } else {
    // Clip by document's size.
    var maxVisibleWidth = Math.max(documentWidth, scrollX + viewportWidth);
    visibleRect.right = Math.min(visibleRect.right, maxVisibleWidth);
    var maxVisibleHeight = Math.max(documentHeight, scrollY + viewportHeight);
    visibleRect.bottom = Math.min(visibleRect.bottom, maxVisibleHeight);
  }

return visibleRect.top >= 0 && visibleRect.left >= 0 && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null;
}

function adjustForViewport(elFuturePos, elRegion, visibleRect, overflow) {
  var pos = utils.clone(elFuturePos);
  var size = {
    width: elRegion.width,
    height: elRegion.height
  };

if (overflow.adjustX && pos.left < visibleRect.left) {
    pos.left = visibleRect.left;
  } // Left edge inside and right edge outside viewport, try to resize it.

if (overflow.resizeWidth && pos.left >= visibleRect.left && pos.left + size.width > visibleRect.right) {
    size.width -= pos.left + size.width - visibleRect.right;
  } // Right edge outside viewport, try to move it.

if (overflow.adjustX && pos.left + size.width > visibleRect.right) {
    // 保证左边界和可视区域左边界对齐
    pos.left = Math.max(visibleRect.right - size.width, visibleRect.left);
  } // Top edge outside viewport, try to move it.

if (overflow.adjustY && pos.top < visibleRect.top) {
    pos.top = visibleRect.top;
  } // Top edge inside and bottom edge outside viewport, try to resize it.

if (overflow.resizeHeight && pos.top >= visibleRect.top && pos.top + size.height > visibleRect.bottom) {
    size.height -= pos.top + size.height - visibleRect.bottom;
  } // Bottom edge outside viewport, try to move it.

if (overflow.adjustY && pos.top + size.height > visibleRect.bottom) {
    // 保证上边界和可视区域上边界对齐
    pos.top = Math.max(visibleRect.bottom - size.height, visibleRect.top);
  }

return utils.mix(pos, size);
}

function getRegion(node) {
  var offset;
  var w;
  var h;

if (!utils.isWindow(node) && node.nodeType !== 9) {
    offset = utils.offset(node);
    w = utils.outerWidth(node);
    h = utils.outerHeight(node);
  } else {
    var win = utils.getWindow(node);
    offset = {
      left: utils.getWindowScrollLeft(win),
      top: utils.getWindowScrollTop(win)
    };
    w = utils.viewportWidth(win);
    h = utils.viewportHeight(win);
  }

offset.width = w;
  offset.height = h;
  return offset;
}

/**
 * 获取 node 上的 align 对齐点 相对于页面的坐标
 */
function getAlignOffset(region, align) {
  var V = align.charAt(0);
  var H = align.charAt(1);
  var w = region.width;
  var h = region.height;
  var x = region.left;
  var y = region.top;

if (V === 'c') {
    y += h / 2;
  } else if (V === 'b') {
    y += h;
  }

if (H === 'c') {
    x += w / 2;
  } else if (H === 'r') {
    x += w;
  }

return {
    left: x,
    top: y
  };
}

function getElFuturePos(elRegion, refNodeRegion, points, offset, targetOffset) {
  var p1 = getAlignOffset(refNodeRegion, points[1]);
  var p2 = getAlignOffset(elRegion, points[0]);
  var diff = [p2.left - p1.left, p2.top - p1.top];
  return {
    left: Math.round(elRegion.left - diff[0] + offset[0] - targetOffset[0]),
    top: Math.round(elRegion.top - diff[1] + offset[1] - targetOffset[1])
  };
}

/**
 * align dom node flexibly
 * @author yiminghe@gmail.com
 */

function isFailX(elFuturePos, elRegion, visibleRect) {
  return elFuturePos.left < visibleRect.left || elFuturePos.left + elRegion.width > visibleRect.right;
}

function isFailY(elFuturePos, elRegion, visibleRect) {
  return elFuturePos.top < visibleRect.top || elFuturePos.top + elRegion.height > visibleRect.bottom;
}

function isCompleteFailX(elFuturePos, elRegion, visibleRect) {
  return elFuturePos.left > visibleRect.right || elFuturePos.left + elRegion.width < visibleRect.left;
}

function isCompleteFailY(elFuturePos, elRegion, visibleRect) {
  return elFuturePos.top > visibleRect.bottom || elFuturePos.top + elRegion.height < visibleRect.top;
}

function flip(points, reg, map) {
  var ret = [];
  utils.each(points, function (p) {
    ret.push(p.replace(reg, function (m) {
      return map[m];
    }));
  });
  return ret;
}

function flipOffset(offset, index) {
  offset[index] = -offset[index];
  return offset;
}

function convertOffset(str, offsetLen) {
  var n;

if (/%$/.test(str)) {
    n = parseInt(str.substring(0, str.length - 1), 10) / 100 * offsetLen;
  } else {
    n = parseInt(str, 10);
  }

return n || 0;
}

function normalizeOffset(offset, el) {
  offset[0] = convertOffset(offset[0], el.width);
  offset[1] = convertOffset(offset[1], el.height);
}
/**
 * @param el
 * @param tgtRegion 参照节点所占的区域: { left, top, width, height }
 * @param align
 */

function doAlign(el, tgtRegion, align, isTgtRegionVisible) {
  var points = align.points;
  var offset = align.offset || [0, 0];
  var targetOffset = align.targetOffset || [0, 0];
  var overflow = align.overflow;
  var source = align.source || el;
  offset = [].concat(offset);
  targetOffset = [].concat(targetOffset);
  overflow = overflow || {};
  var newOverflowCfg = {};
  var fail = 0;
  var alwaysByViewport = !!(overflow && overflow.alwaysByViewport); // 当前节点可以被放置的显示区域

var visibleRect = getVisibleRectForElement(source, alwaysByViewport); // 当前节点所占的区域, left/top/width/height

var elRegion = getRegion(source); // 将 offset 转换成数值，支持百分比

normalizeOffset(offset, elRegion);
  normalizeOffset(targetOffset, tgtRegion); // 当前节点将要被放置的位置

var elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset, targetOffset); // 当前节点将要所处的区域

var newElRegion = utils.merge(elRegion, elFuturePos); // 如果可视区域不能完全放置当前节点时允许调整

if (visibleRect && (overflow.adjustX || overflow.adjustY) && isTgtRegionVisible) {
    if (overflow.adjustX) {
      // 如果横向不能放下
      if (isFailX(elFuturePos, elRegion, visibleRect)) {
        // 对齐位置反下
        var newPoints = flip(points, /[lr]/gi, {
          l: 'r',
          r: 'l'
        }); // 偏移量也反下

var newOffset = flipOffset(offset, 0);
        var newTargetOffset = flipOffset(targetOffset, 0);
        var newElFuturePos = getElFuturePos(elRegion, tgtRegion, newPoints, newOffset, newTargetOffset);

if (!isCompleteFailX(newElFuturePos, elRegion, visibleRect)) {
          fail = 1;
          points = newPoints;
          offset = newOffset;
          targetOffset = newTargetOffset;
        }
      }
    }

if (overflow.adjustY) {
      // 如果纵向不能放下
      if (isFailY(elFuturePos, elRegion, visibleRect)) {
        // 对齐位置反下
        var _newPoints = flip(points, /[tb]/gi, {
          t: 'b',
          b: 't'
        }); // 偏移量也反下

var _newOffset = flipOffset(offset, 1);

var _newTargetOffset = flipOffset(targetOffset, 1);

var _newElFuturePos = getElFuturePos(elRegion, tgtRegion, _newPoints, _newOffset, _newTargetOffset);

if (!isCompleteFailY(_newElFuturePos, elRegion, visibleRect)) {
          fail = 1;
          points = _newPoints;
          offset = _newOffset;
          targetOffset = _newTargetOffset;
        }
      }
    } // 如果失败，重新计算当前节点将要被放置的位置

if (fail) {
      elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset, targetOffset);
      utils.mix(newElRegion, elFuturePos);
    }

var isStillFailX = isFailX(elFuturePos, elRegion, visibleRect);
    var isStillFailY = isFailY(elFuturePos, elRegion, visibleRect); // 检查反下后的位置是否可以放下了，如果仍然放不下：
    // 1. 复原修改过的定位参数

if (isStillFailX || isStillFailY) {
      var _newPoints2 = points; // 重置对应部分的翻转逻辑

if (isStillFailX) {
        _newPoints2 = flip(points, /[lr]/gi, {
          l: 'r',
          r: 'l'
        });
      }

if (isStillFailY) {
        _newPoints2 = flip(points, /[tb]/gi, {
          t: 'b',
          b: 't'
        });
      }

points = _newPoints2;
      offset = align.offset || [0, 0];
      targetOffset = align.targetOffset || [0, 0];
    } // 2. 只有指定了可以调整当前方向才调整

newOverflowCfg.adjustX = overflow.adjustX && isStillFailX;
    newOverflowCfg.adjustY = overflow.adjustY && isStillFailY; // 确实要调整，甚至可能会调整高度宽度

if (newOverflowCfg.adjustX || newOverflowCfg.adjustY) {
      newElRegion = adjustForViewport(elFuturePos, elRegion, visibleRect, newOverflowCfg);
    }
  } // need judge to in case set fixed with in css on height auto element

if (newElRegion.width !== elRegion.width) {
    utils.css(source, 'width', utils.width(source) + newElRegion.width - elRegion.width);
  }

if (newElRegion.height !== elRegion.height) {
    utils.css(source, 'height', utils.height(source) + newElRegion.height - elRegion.height);
  } // https://github.com/kissyteam/kissy/issues/190
  // 相对于屏幕位置没变，而 left/top 变了
  // 例如 <div 'relative'><el absolute></div>

utils.offset(source, {
    left: newElRegion.left,
    top: newElRegion.top
  }, {
    useCssRight: align.useCssRight,
    useCssBottom: align.useCssBottom,
    useCssTransform: align.useCssTransform,
    ignoreShake: align.ignoreShake
  });
  return {
    points: points,
    offset: offset,
    targetOffset: targetOffset,
    overflow: newOverflowCfg
  };
}
/**
 *  2012-04-26 yiminghe@gmail.com
 *   - 优化智能对齐算法
 *   - 慎用 resizeXX
 *
 *  2011-07-13 yiminghe@gmail.com note:
 *   - 增加智能对齐，以及大小调整选项
 **/

function isOutOfVisibleRect(target, alwaysByViewport) {
  var visibleRect = getVisibleRectForElement(target, alwaysByViewport);
  var targetRegion = getRegion(target);
  return !visibleRect || targetRegion.left + targetRegion.width <= visibleRect.left || targetRegion.top + targetRegion.height <= visibleRect.top || targetRegion.left >= visibleRect.right || targetRegion.top >= visibleRect.bottom;
}

function alignElement(el, refNode, align) {
  var target = align.target || refNode;
  var refNodeRegion = getRegion(target);
  var isTargetNotOutOfVisible = !isOutOfVisibleRect(target, align.overflow && align.overflow.alwaysByViewport);
  return doAlign(el, refNodeRegion, align, isTargetNotOutOfVisible);
}

alignElement.__getOffsetParent = getOffsetParent;
alignElement.__getVisibleRectForElement = getVisibleRectForElement;

/**
 * `tgtPoint`: { pageX, pageY } or { clientX, clientY }.
 * If client position provided, will internal convert to page position.
 */

function alignPoint(el, tgtPoint, align) {
  var pageX;
  var pageY;
  var doc = utils.getDocument(el);
  var win = doc.defaultView || doc.parentWindow;
  var scrollX = utils.getWindowScrollLeft(win);
  var scrollY = utils.getWindowScrollTop(win);
  var viewportWidth = utils.viewportWidth(win);
  var viewportHeight = utils.viewportHeight(win);

if ('pageX' in tgtPoint) {
    pageX = tgtPoint.pageX;
  } else {
    pageX = scrollX + tgtPoint.clientX;
  }

if ('pageY' in tgtPoint) {
    pageY = tgtPoint.pageY;
  } else {
    pageY = scrollY + tgtPoint.clientY;
  }

var tgtRegion = {
    left: pageX,
    top: pageY,
    width: 0,
    height: 0
  };
  var pointInView = pageX >= 0 && pageX <= scrollX + viewportWidth && pageY >= 0 && pageY <= scrollY + viewportHeight; // Provide default target point

var points = [align.points[0], 'cc'];
  return doAlign(el, tgtRegion, _objectSpread2(_objectSpread2({}, align), {}, {
    points: points
  }), pointInView);
}

/* unused harmony default export */ var _unused_webpack_default_export = (alignElement);

//# sourceMappingURL=index.js.map

/***/ }),
/* 864 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _interopRequireDefault = __webpack_require__(591);

exports.__esModule = true;
exports.default = addClass;

var _hasClass = _interopRequireDefault(__webpack_require__(865));

function addClass(element, className) {
  if (element.classList) element.classList.add(className);else if (!(0, _hasClass.default)(element, className)) if (typeof element.className === 'string') element.className = element.className + ' ' + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + ' ' + className);
}

module.exports = exports["default"];

/***/ }),
/* 865 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.default = hasClass;

function hasClass(element, className) {
  if (element.classList) return !!className && element.classList.contains(className);else return (" " + (element.className.baseVal || element.className) + " ").indexOf(" " + className + " ") !== -1;
}

module.exports = exports["default"];

/***/ }),
/* 866 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

function replaceClassName(origClass, classToRemove) {
  return origClass.replace(new RegExp('(^|\\s)' + classToRemove + '(?:\\s|$)', 'g'), '$1').replace(/\s+/g, ' ').replace(/^\s*|\s*$/g, '');
}

module.exports = function removeClass(element, className) {
  if (element.classList) element.classList.remove(className);else if (typeof element.className === 'string') element.className = replaceClassName(element.className, className);else element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));
};

/***/ }),
/* 867 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var util = __webpack_require__(868);

function scrollIntoView(elem, container, config) {
  config = config || {};
  // document 归一化到 window
  if (container.nodeType === 9) {
    container = util.getWindow(container);
  }

var allowHorizontalScroll = config.allowHorizontalScroll;
  var onlyScrollIfNeeded = config.onlyScrollIfNeeded;
  var alignWithTop = config.alignWithTop;
  var alignWithLeft = config.alignWithLeft;
  var offsetTop = config.offsetTop || 0;
  var offsetLeft = config.offsetLeft || 0;
  var offsetBottom = config.offsetBottom || 0;
  var offsetRight = config.offsetRight || 0;

allowHorizontalScroll = allowHorizontalScroll === undefined ? true : allowHorizontalScroll;

var isWin = util.isWindow(container);
  var elemOffset = util.offset(elem);
  var eh = util.outerHeight(elem);
  var ew = util.outerWidth(elem);
  var containerOffset = undefined;
  var ch = undefined;
  var cw = undefined;
  var containerScroll = undefined;
  var diffTop = undefined;
  var diffBottom = undefined;
  var win = undefined;
  var winScroll = undefined;
  var ww = undefined;
  var wh = undefined;

if (isWin) {
    win = container;
    wh = util.height(win);
    ww = util.width(win);
    winScroll = {
      left: util.scrollLeft(win),
      top: util.scrollTop(win)
    };
    // elem 相对 container 可视视窗的距离
    diffTop = {
      left: elemOffset.left - winScroll.left - offsetLeft,
      top: elemOffset.top - winScroll.top - offsetTop
    };
    diffBottom = {
      left: elemOffset.left + ew - (winScroll.left + ww) + offsetRight,
      top: elemOffset.top + eh - (winScroll.top + wh) + offsetBottom
    };
    containerScroll = winScroll;
  } else {
    containerOffset = util.offset(container);
    ch = container.clientHeight;
    cw = container.clientWidth;
    containerScroll = {
      left: container.scrollLeft,
      top: container.scrollTop
    };
    // elem 相对 container 可视视窗的距离
    // 注意边框, offset 是边框到根节点
    diffTop = {
      left: elemOffset.left - (containerOffset.left + (parseFloat(util.css(container, 'borderLeftWidth')) || 0)) - offsetLeft,
      top: elemOffset.top - (containerOffset.top + (parseFloat(util.css(container, 'borderTopWidth')) || 0)) - offsetTop
    };
    diffBottom = {
      left: elemOffset.left + ew - (containerOffset.left + cw + (parseFloat(util.css(container, 'borderRightWidth')) || 0)) + offsetRight,
      top: elemOffset.top + eh - (containerOffset.top + ch + (parseFloat(util.css(container, 'borderBottomWidth')) || 0)) + offsetBottom
    };
  }

if (diffTop.top < 0 || diffBottom.top > 0) {
    // 强制向上
    if (alignWithTop === true) {
      util.scrollTop(container, containerScroll.top + diffTop.top);
    } else if (alignWithTop === false) {
      util.scrollTop(container, containerScroll.top + diffBottom.top);
    } else {
      // 自动调整
      if (diffTop.top < 0) {
        util.scrollTop(container, containerScroll.top + diffTop.top);
      } else {
        util.scrollTop(container, containerScroll.top + diffBottom.top);
      }
    }
  } else {
    if (!onlyScrollIfNeeded) {
      alignWithTop = alignWithTop === undefined ? true : !!alignWithTop;
      if (alignWithTop) {
        util.scrollTop(container, containerScroll.top + diffTop.top);
      } else {
        util.scrollTop(container, containerScroll.top + diffBottom.top);
      }
    }
  }

if (allowHorizontalScroll) {
    if (diffTop.left < 0 || diffBottom.left > 0) {
      // 强制向上
      if (alignWithLeft === true) {
        util.scrollLeft(container, containerScroll.left + diffTop.left);
      } else if (alignWithLeft === false) {
        util.scrollLeft(container, containerScroll.left + diffBottom.left);
      } else {
        // 自动调整
        if (diffTop.left < 0) {
          util.scrollLeft(container, containerScroll.left + diffTop.left);
        } else {
          util.scrollLeft(container, containerScroll.left + diffBottom.left);
        }
      }
    } else {
      if (!onlyScrollIfNeeded) {
        alignWithLeft = alignWithLeft === undefined ? true : !!alignWithLeft;
        if (alignWithLeft) {
          util.scrollLeft(container, containerScroll.left + diffTop.left);
        } else {
          util.scrollLeft(container, containerScroll.left + diffBottom.left);
        }
      }
    }
  }
}

module.exports = scrollIntoView;

/***/ }),
/* 868 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source;

function getClientPosition(elem) {
  var box = undefined;
  var x = undefined;
  var y = undefined;
  var doc = elem.ownerDocument;
  var body = doc.body;
  var docElem = doc && doc.documentElement;
  // 根据 GBS 最新数据，A-Grade Browsers 都已支持 getBoundingClientRect 方法，不用再考虑传统的实现方式
  box = elem.getBoundingClientRect();

// 注：jQuery 还考虑减去 docElem.clientLeft/clientTop
  // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确
  // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin

x = box.left;
  y = box.top;

// In IE, most of the time, 2 extra pixels are added to the top and left
  // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
  // IE6 standards mode, this border can be overridden by setting the
  // document element's border to zero -- thus, we cannot rely on the
  // offset always being 2 pixels.

// In quirks mode, the offset can be determined by querying the body's
  // clientLeft/clientTop, but in standards mode, it is found by querying
  // the document element's clientLeft/clientTop.  Since we already called
  // getClientBoundingRect we have already forced a reflow, so it is not
  // too expensive just to query them all.

// ie 下应该减去窗口的边框吧，毕竟默认 absolute 都是相对窗口定位的
  // 窗口边框标准是设 documentElement ,quirks 时设置 body
  // 最好禁止在 body 和 html 上边框 ，但 ie < 9 html 默认有 2px ，减去
  // 但是非 ie 不可能设置窗口边框，body html 也不是窗口 ,ie 可以通过 html,body 设置
  // 标准 ie 下 docElem.clientTop 就是 border-top
  // ie7 html 即窗口边框改变不了。永远为 2
  // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框，即使设了 border-top 也为 0

x -= docElem.clientLeft || body.clientLeft || 0;
  y -= docElem.clientTop || body.clientTop || 0;

return {
    left: x,
    top: y
  };
}

function getScrollLeft(w) {
  return getScroll(w);
}

function getScrollTop(w) {
  return getScroll(w, true);
}

function getOffset(el) {
  var pos = getClientPosition(el);
  var doc = el.ownerDocument;
  var w = doc.defaultView || doc.parentWindow;
  pos.left += getScrollLeft(w);
  pos.top += getScrollTop(w);
  return pos;
}
function _getComputedStyle(elem, name, computedStyle_) {
  var val = '';
  var d = elem.ownerDocument;
  var computedStyle = computedStyle_ || d.defaultView.getComputedStyle(elem, null);

// https://github.com/kissyteam/kissy/issues/61
  if (computedStyle) {
    val = computedStyle.getPropertyValue(name) || computedStyle[name];
  }

return val;
}

var _RE_NUM_NO_PX = new RegExp('^(' + RE_NUM + ')(?!px)[a-z%]+$', 'i');
var RE_POS = /^(top|right|bottom|left)$/;
var CURRENT_STYLE = 'currentStyle';
var RUNTIME_STYLE = 'runtimeStyle';
var LEFT = 'left';
var PX = 'px';

function _getComputedStyleIE(elem, name) {
  // currentStyle maybe null
  // http://msdn.microsoft.com/en-us/library/ms535231.aspx
  var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name];

// 当 width/height 设置为百分比时，通过 pixelLeft 方式转换的 width/height 值
  // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19
  // 在 ie 下不对，需要直接用 offset 方式
  // borderWidth 等值也有问题，但考虑到 borderWidth 设为百分比的概率很小，这里就不考虑了

// From the awesome hack by Dean Edwards
  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
  // If we're not dealing with a regular pixel number
  // but a number that has a weird ending, we need to convert it to pixels
  // exclude left right for relativity
  if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {
    // Remember the original values
    var style = elem.style;
    var left = style[LEFT];
    var rsLeft = elem[RUNTIME_STYLE][LEFT];

// prevent flashing of content
    elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT];

// Put in the new values to get a computed value out
    style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;
    ret = style.pixelLeft + PX;

// Revert the changed values
    style[LEFT] = left;

elem[RUNTIME_STYLE][LEFT] = rsLeft;
  }
  return ret === '' ? 'auto' : ret;
}

var getComputedStyleX = undefined;
if (typeof window !== 'undefined') {
  getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;
}

function each(arr, fn) {
  for (var i = 0; i < arr.length; i++) {
    fn(arr[i]);
  }
}

function isBorderBoxFn(elem) {
  return getComputedStyleX(elem, 'boxSizing') === 'border-box';
}

var BOX_MODELS = ['margin', 'border', 'padding'];
var CONTENT_INDEX = -1;
var PADDING_INDEX = 2;
var BORDER_INDEX = 1;
var MARGIN_INDEX = 0;

function swap(elem, options, callback) {
  var old = {};
  var style = elem.style;
  var name = undefined;

// Remember the old values, and insert the new ones
  for (name in options) {
    if (options.hasOwnProperty(name)) {
      old[name] = style[name];
      style[name] = options[name];
    }
  }

callback.call(elem);

// Revert the old values
  for (name in options) {
    if (options.hasOwnProperty(name)) {
      style[name] = old[name];
    }
  }
}

/**
 * A crude way of determining if an object is a window
 * @member util
 */
function isWindow(obj) {
  // must use == for ie8
  /* eslint eqeqeq:0 */
  return obj != null && obj == obj.window;
}

var domUtils = {};

each(['Width', 'Height'], function (name) {
  domUtils['doc' + name] = function (refWin) {
    var d = refWin.document;
    return Math.max(
    // firefox chrome documentElement.scrollHeight< body.scrollHeight
    // ie standard mode : documentElement.scrollHeight> body.scrollHeight
    d.documentElement['scroll' + name],
    // quirks : documentElement.scrollHeight 最大等于可视窗口多一点？
    d.body['scroll' + name], domUtils['viewport' + name](d));
  };

domUtils['viewport' + name] = function (win) {
    // pc browser includes scrollbar in window.innerWidth
    var prop = 'client' + name;
    var doc = win.document;
    var body = doc.body;
    var documentElement = doc.documentElement;
    var documentElementProp = documentElement[prop];
    // 标准模式取 documentElement
    // backcompat 取 body
    return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;
  };
});

/*
 得到元素的大小信息
 @param elem
 @param name
 @param {String} [extra]  'padding' : (css width) + padding
 'border' : (css width) + padding + border
 'margin' : (css width) + padding + border + margin
 */
function getWH(elem, name, extra) {
  if (isWindow(elem)) {
    return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
  } else if (elem.nodeType === 9) {
    return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
  }
  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
  var borderBoxValue = name === 'width' ? elem.offsetWidth : elem.offsetHeight;
  var computedStyle = getComputedStyleX(elem);
  var isBorderBox = isBorderBoxFn(elem, computedStyle);
  var cssBoxValue = 0;
  if (borderBoxValue == null || borderBoxValue <= 0) {
    borderBoxValue = undefined;
    // Fall back to computed then un computed css if necessary
    cssBoxValue = getComputedStyleX(elem, name);
    if (cssBoxValue == null || Number(cssBoxValue) < 0) {
      cssBoxValue = elem.style[name] || 0;
    }
    // Normalize '', auto, and prepare for extra
    cssBoxValue = parseFloat(cssBoxValue) || 0;
  }
  if (extra === undefined) {
    extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
  }
  var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;
  var val = borderBoxValue || cssBoxValue;
  if (extra === CONTENT_INDEX) {
    if (borderBoxValueOrIsBorderBox) {
      return val - getPBMWidth(elem, ['border', 'padding'], which, computedStyle);
    }
    return cssBoxValue;
  }
  if (borderBoxValueOrIsBorderBox) {
    var padding = extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which, computedStyle) : getPBMWidth(elem, ['margin'], which, computedStyle);
    return val + (extra === BORDER_INDEX ? 0 : padding);
  }
  return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which, computedStyle);
}

var cssShow = {
  position: 'absolute',
  visibility: 'hidden',
  display: 'block'
};

// fix #119 : https://github.com/kissyteam/kissy/issues/119
function getWHIgnoreDisplay(elem) {
  var val = undefined;
  var args = arguments;
  // in case elem is window
  // elem.offsetWidth === undefined
  if (elem.offsetWidth !== 0) {
    val = getWH.apply(undefined, args);
  } else {
    swap(elem, cssShow, function () {
      val = getWH.apply(undefined, args);
    });
  }
  return val;
}

each(['width', 'height'], function (name) {
  var first = name.charAt(0).toUpperCase() + name.slice(1);
  domUtils['outer' + first] = function (el, includeMargin) {
    return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
  };
  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];

domUtils[name] = function (elem, val) {
    if (val !== undefined) {
      if (elem) {
        var computedStyle = getComputedStyleX(elem);
        var isBorderBox = isBorderBoxFn(elem);
        if (isBorderBox) {
          val += getPBMWidth(elem, ['padding', 'border'], which, computedStyle);
        }
        return css(elem, name, val);
      }
      return undefined;
    }
    return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
  };
});

// 设置 elem 相对 elem.ownerDocument 的坐标
function setOffset(elem, offset) {
  // set position first, in-case top/left are set even on static elem
  if (css(elem, 'position') === 'static') {
    elem.style.position = 'relative';
  }

var old = getOffset(elem);
  var ret = {};
  var current = undefined;
  var key = undefined;

for (key in offset) {
    if (offset.hasOwnProperty(key)) {
      current = parseFloat(css(elem, key)) || 0;
      ret[key] = current + offset[key] - old[key];
    }
  }
  css(elem, ret);
}

module.exports = _extends({
  getWindow: function getWindow(node) {
    var doc = node.ownerDocument || node;
    return doc.defaultView || doc.parentWindow;
  },
  offset: function offset(el, value) {
    if (typeof value !== 'undefined') {
      setOffset(el, value);
    } else {
      return getOffset(el);
    }
  },

isWindow: isWindow,
  each: each,
  css: css,
  clone: function clone(obj) {
    var ret = {};
    for (var i in obj) {
      if (obj.hasOwnProperty(i)) {
        ret[i] = obj[i];
      }
    }
    var overflow = obj.overflow;
    if (overflow) {
      for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
          ret.overflow[i] = obj.overflow[i];
        }
      }
    }
    return ret;
  },
  scrollLeft: function scrollLeft(w, v) {
    if (isWindow(w)) {
      if (v === undefined) {
        return getScrollLeft(w);
      }
      window.scrollTo(v, getScrollTop(w));
    } else {
      if (v === undefined) {
        return w.scrollLeft;
      }
      w.scrollLeft = v;
    }
  },
  scrollTop: function scrollTop(w, v) {
    if (isWindow(w)) {
      if (v === undefined) {
        return getScrollTop(w);
      }
      window.scrollTo(getScrollLeft(w), v);
    } else {
      if (v === undefined) {
        return w.scrollTop;
      }
      w.scrollTop = v;
    }
  },

viewportWidth: 0,
  viewportHeight: 0
}, domUtils);

/***/ }),
/* 869 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Resize detection strategy that injects objects to elements in order to detect resize events.
 * Heavily inspired by: http://www.backalleycoder.com/2013/03/18/cross-browser-event-based-element-resize-detection/
 */

var browserDetector = __webpack_require__(403);

if(!reporter) {
        throw new Error("Missing required dependency: reporter.");
    }

/**
     * Adds a resize event listener to the element.
     * @public
     * @param {element} element The element that should have the listener added.
     * @param {function} listener The listener callback to be called for each resize event of the element. The element will be given as a parameter to the listener callback.
     */
    function addListener(element, listener) {
        function listenerProxy() {
            listener(element);
        }

if(browserDetector.isIE(8)) {
            //IE 8 does not support object, but supports the resize event directly on elements.
            getState(element).object = {
                proxy: listenerProxy
            };
            element.attachEvent("onresize", listenerProxy);
        } else {
            var object = getObject(element);

if(!object) {
                throw new Error("Element is not detectable by this strategy.");
            }

object.contentDocument.defaultView.addEventListener("resize", listenerProxy);
        }
    }

function buildCssTextString(rules) {
        var seperator = options.important ? " !important; " : "; ";

return (rules.join(seperator) + seperator).trim();
    }

/**
     * Makes an element detectable and ready to be listened for resize events. Will call the callback when the element is ready to be listened for resize changes.
     * @private
     * @param {object} options Optional options object.
     * @param {element} element The element to make detectable
     * @param {function} callback The callback to be called when the element is ready to be listened for resize changes. Will be called with the element as first parameter.
     */
    function makeDetectable(options, element, callback) {
        if (!callback) {
            callback = element;
            element = options;
            options = null;
        }

options = options || {};
        var debug = options.debug;

function injectObject(element, callback) {
            var OBJECT_STYLE = buildCssTextString(["display: block", "position: absolute", "top: 0", "left: 0", "width: 100%", "height: 100%", "border: none", "padding: 0", "margin: 0", "opacity: 0", "z-index: -1000", "pointer-events: none"]);

//The target element needs to be positioned (everything except static) so the absolute positioned object will be positioned relative to the target element.

// Position altering may be performed directly or on object load, depending on if style resolution is possible directly or not.
            var positionCheckPerformed = false;

// The element may not yet be attached to the DOM, and therefore the style object may be empty in some browsers.
            // Since the style object is a reference, it will be updated as soon as the element is attached to the DOM.
            var style = window.getComputedStyle(element);
            var width = element.offsetWidth;
            var height = element.offsetHeight;

getState(element).startSize = {
                width: width,
                height: height
            };

function mutateDom() {
                function alterPositionStyles() {
                    if(style.position === "static") {
                        element.style.setProperty("position", "relative", options.important ? "important" : "");

var removeRelativeStyles = function(reporter, element, style, property) {
                            function getNumericalValue(value) {
                                return value.replace(/[^-\d\.]/g, "");
                            }

var value = style[property];

if(value !== "auto" && getNumericalValue(value) !== "0") {
                                reporter.warn("An element that is positioned static has style." + property + "=" + value + " which is ignored due to the static positioning. The element will need to be positioned relative, so the style." + property + " will be set to 0. Element: ", element);
                                element.style.setProperty(property, "0", options.important ? "important" : "");
                            }
                        };

//Check so that there are no accidental styles that will make the element styled differently now that is is relative.
                        //If there are any, set them to 0 (this should be okay with the user since the style properties did nothing before [since the element was positioned static] anyway).
                        removeRelativeStyles(reporter, element, style, "top");
                        removeRelativeStyles(reporter, element, style, "right");
                        removeRelativeStyles(reporter, element, style, "bottom");
                        removeRelativeStyles(reporter, element, style, "left");
                    }
                }

function onObjectLoad() {
                    // The object has been loaded, which means that the element now is guaranteed to be attached to the DOM.
                    if (!positionCheckPerformed) {
                        alterPositionStyles();
                    }

/*jshint validthis: true */

function getDocument(element, callback) {
                        //Opera 12 seem to call the object.onload before the actual document has been created.
                        //So if it is not present, poll it with an timeout until it is present.
                        //TODO: Could maybe be handled better with object.onreadystatechange or similar.
                        if(!element.contentDocument) {
                            var state = getState(element);
                            if (state.checkForObjectDocumentTimeoutId) {
                                window.clearTimeout(state.checkForObjectDocumentTimeoutId);
                            }
                            state.checkForObjectDocumentTimeoutId = setTimeout(function checkForObjectDocument() {
                                state.checkForObjectDocumentTimeoutId = 0;
                                getDocument(element, callback);
                            }, 100);

return;
                        }

callback(element.contentDocument);
                    }

//Mutating the object element here seems to fire another load event.
                    //Mutating the inner document of the object element is fine though.
                    var objectElement = this;

//Create the style element to be added to the object.
                    getDocument(objectElement, function onObjectDocumentReady(objectDocument) {
                        //Notify that the element is ready to be listened to.
                        callback(element);
                    });
                }

// The element may be detached from the DOM, and some browsers does not support style resolving of detached elements.
                // The alterPositionStyles needs to be delayed until we know the element has been attached to the DOM (which we are sure of when the onObjectLoad has been fired), if style resolution is not possible.
                if (style.position !== "") {
                    alterPositionStyles(style);
                    positionCheckPerformed = true;
                }

//Add an object element as a child to the target element that will be listened to for resize events.
                var object = document.createElement("object");
                object.style.cssText = OBJECT_STYLE;
                object.tabIndex = -1;
                object.type = "text/html";
                object.setAttribute("aria-hidden", "true");
                object.onload = onObjectLoad;

//Safari: This must occur before adding the object to the DOM.
                //IE: Does not like that this happens before, even if it is also added after.
                if(!browserDetector.isIE()) {
                    object.data = "about:blank";
                }

if (!getState(element)) {
                    // The element has been uninstalled before the actual loading happened.
                    return;
                }

element.appendChild(object);
                getState(element).object = object;

//IE: This must occur after adding the object to the DOM.
                if(browserDetector.isIE()) {
                    object.data = "about:blank";
                }
            }

if(batchProcessor) {
                batchProcessor.add(mutateDom);
            } else {
                mutateDom();
            }
        }

if(browserDetector.isIE(8)) {
            //IE 8 does not support objects properly. Luckily they do support the resize event.
            //So do not inject the object and notify that the element is already ready to be listened to.
            //The event handler for the resize event is attached in the utils.addListener instead.
            callback(element);
        } else {
            injectObject(element, callback);
        }
    }

/**
     * Returns the child object of the target element.
     * @private
     * @param {element} element The target element.
     * @returns The object element of the target.
     */
    function getObject(element) {
        return getState(element).object;
    }

function uninstall(element) {
        if (!getState(element)) {
            return;
        }

var object = getObject(element);

if (!object) {
            return;
        }

if (browserDetector.isIE(8)) {
            element.detachEvent("onresize", object.proxy);
        } else {
            element.removeChild(object);
        }

if (getState(element).checkForObjectDocumentTimeoutId) {
            window.clearTimeout(getState(element).checkForObjectDocumentTimeoutId);
        }

delete getState(element).object;
    }

return {
        makeDetectable: makeDetectable,
        addListener: addListener,
        uninstall: uninstall
    };
};

/***/ }),
/* 870 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Resize detection strategy that injects divs to elements in order to detect resize events on scroll events.
 * Heavily inspired by: https://github.com/marcj/css-element-queries/blob/master/src/ResizeSensor.js
 */

var forEach = __webpack_require__(404).forEach;

module.exports = function(options) {
    options             = options || {};
    var reporter        = options.reporter;
    var batchProcessor  = options.batchProcessor;
    var getState        = options.stateHandler.getState;
    var hasState        = options.stateHandler.hasState;
    var idHandler       = options.idHandler;

if (!batchProcessor) {
        throw new Error("Missing required dependency: batchProcessor");
    }

if (!reporter) {
        throw new Error("Missing required dependency: reporter.");
    }

//TODO: Could this perhaps be done at installation time?
    var scrollbarSizes = getScrollbarSizes();

var styleId = "erd_scroll_detection_scrollbar_style";
    var detectionContainerClass = "erd_scroll_detection_container";

function initDocument(targetDocument) {
        // Inject the scrollbar styling that prevents them from appearing sometimes in Chrome.
        // The injected container needs to have a class, so that it may be styled with CSS (pseudo elements).
        injectScrollStyle(targetDocument, styleId, detectionContainerClass);
    }

initDocument(window.document);

function buildCssTextString(rules) {
        var seperator = options.important ? " !important; " : "; ";

return (rules.join(seperator) + seperator).trim();
    }

function getScrollbarSizes() {
        var width = 500;
        var height = 500;

var child = document.createElement("div");
        child.style.cssText = buildCssTextString(["position: absolute", "width: " + width*2 + "px", "height: " + height*2 + "px", "visibility: hidden", "margin: 0", "padding: 0"]);

var container = document.createElement("div");
        container.style.cssText = buildCssTextString(["position: absolute", "width: " + width + "px", "height: " + height + "px", "overflow: scroll", "visibility: none", "top: " + -width*3 + "px", "left: " + -height*3 + "px", "visibility: hidden", "margin: 0", "padding: 0"]);

container.appendChild(child);

document.body.insertBefore(container, document.body.firstChild);

var widthSize = width - container.clientWidth;
        var heightSize = height - container.clientHeight;

document.body.removeChild(container);

return {
            width: widthSize,
            height: heightSize
        };
    }

function injectScrollStyle(targetDocument, styleId, containerClass) {
        function injectStyle(style, method) {
            method = method || function (element) {
                targetDocument.head.appendChild(element);
            };

var styleElement = targetDocument.createElement("style");
            styleElement.innerHTML = style;
            styleElement.id = styleId;
            method(styleElement);
            return styleElement;
        }

if (!targetDocument.getElementById(styleId)) {
            var containerAnimationClass = containerClass + "_animation";
            var containerAnimationActiveClass = containerClass + "_animation_active";
            var style = "/* Created by the element-resize-detector library. */\n";
            style += "." + containerClass + " > div::-webkit-scrollbar { " + buildCssTextString(["display: none"]) + " }\n\n";
            style += "." + containerAnimationActiveClass + " { " + buildCssTextString(["-webkit-animation-duration: 0.1s", "animation-duration: 0.1s", "-webkit-animation-name: " + containerAnimationClass, "animation-name: " + containerAnimationClass]) + " }\n";
            style += "@-webkit-keyframes " + containerAnimationClass +  " { 0% { opacity: 1; } 50% { opacity: 0; } 100% { opacity: 1; } }\n";
            style += "@keyframes " + containerAnimationClass +          " { 0% { opacity: 1; } 50% { opacity: 0; } 100% { opacity: 1; } }";
            injectStyle(style);
        }
    }

function addAnimationClass(element) {
        element.className += " " + detectionContainerClass + "_animation_active";
    }

function getExpandElement(element) {
        return getState(element).container.childNodes[0].childNodes[0].childNodes[0];
    }

function getShrinkElement(element) {
        return getState(element).container.childNodes[0].childNodes[0].childNodes[1];
    }

if (!listeners.push) {
            throw new Error("Cannot add listener to an element that is not detectable.");
        }

getState(element).listeners.push(listener);
    }

options = options || {};

function isDetached(element) {
            function isInDocument(element) {
                var isInShadowRoot = element.getRootNode && element.getRootNode().contains(element);
                return element === element.ownerDocument.body || element.ownerDocument.body.contains(element) || isInShadowRoot;
            }

if (!isInDocument(element)) {
                return true;
            }

// FireFox returns null style in hidden iframes. See https://github.com/wnr/element-resize-detector/issues/68 and https://bugzilla.mozilla.org/show_bug.cgi?id=795520
            if (window.getComputedStyle(element) === null) {
                return true;
            }

return false;
        }

function isUnrendered(element) {
            // Check the absolute positioned container since the top level container is display: inline.
            var container = getState(element).container.childNodes[0];
            var style = window.getComputedStyle(container);
            return !style.width || style.width.indexOf("px") === -1; //Can only compute pixel value when rendered.
        }

function getStyle() {
            // Some browsers only force layouts when actually reading the style properties of the style object, so make sure that they are all read here,
            // so that the user of the function can be sure that it will perform the layout here, instead of later (important for batching).
            var elementStyle            = window.getComputedStyle(element);
            var style                   = {};
            style.position              = elementStyle.position;
            style.width                 = element.offsetWidth;
            style.height                = element.offsetHeight;
            style.top                   = elementStyle.top;
            style.right                 = elementStyle.right;
            style.bottom                = elementStyle.bottom;
            style.left                  = elementStyle.left;
            style.widthCSS              = elementStyle.width;
            style.heightCSS             = elementStyle.height;
            return style;
        }

function storeStartSize() {
            var style = getStyle();
            getState(element).startSize = {
                width: style.width,
                height: style.height
            };
            debug("Element start size", getState(element).startSize);
        }

function initListeners() {
            getState(element).listeners = [];
        }

function storeStyle() {
            debug("storeStyle invoked.");
            if (!getState(element)) {
                debug("Aborting because element has been uninstalled");
                return;
            }

var style = getStyle();
            getState(element).style = style;
        }

function storeCurrentSize(element, width, height) {
            getState(element).lastWidth = width;
            getState(element).lastHeight  = height;
        }

function getExpandChildElement(element) {
            return getExpandElement(element).childNodes[0];
        }

function getWidthOffset() {
            return 2 * scrollbarSizes.width + 1;
        }

function getHeightOffset() {
            return 2 * scrollbarSizes.height + 1;
        }

function getExpandWidth(width) {
            return width + 10 + getWidthOffset();
        }

function getExpandHeight(height) {
            return height + 10 + getHeightOffset();
        }

function getShrinkWidth(width) {
            return width * 2 + getWidthOffset();
        }

function getShrinkHeight(height) {
            return height * 2 + getHeightOffset();
        }

function positionScrollbars(element, width, height) {
            var expand          = getExpandElement(element);
            var shrink          = getShrinkElement(element);
            var expandWidth     = getExpandWidth(width);
            var expandHeight    = getExpandHeight(height);
            var shrinkWidth     = getShrinkWidth(width);
            var shrinkHeight    = getShrinkHeight(height);
            expand.scrollLeft   = expandWidth;
            expand.scrollTop    = expandHeight;
            shrink.scrollLeft   = shrinkWidth;
            shrink.scrollTop    = shrinkHeight;
        }

function injectContainerElement() {
            var container = getState(element).container;

if (!container) {
                container                   = document.createElement("div");
                container.className         = detectionContainerClass;
                container.style.cssText     = buildCssTextString(["visibility: hidden", "display: inline", "width: 0px", "height: 0px", "z-index: -1", "overflow: hidden", "margin: 0", "padding: 0"]);
                getState(element).container = container;
                addAnimationClass(container);
                element.appendChild(container);

var onAnimationStart = function () {
                    getState(element).onRendered && getState(element).onRendered();
                };

addEvent(container, "animationstart", onAnimationStart);

// Store the event handler here so that they may be removed when uninstall is called.
                // See uninstall function for an explanation why it is needed.
                getState(element).onAnimationStart = onAnimationStart;
            }

return container;
        }

function injectScrollElements() {
            function alterPositionStyles() {
                var style = getState(element).style;

if(style.position === "static") {
                    element.style.setProperty("position", "relative",options.important ? "important" : "");

var removeRelativeStyles = function(reporter, element, style, property) {
                        function getNumericalValue(value) {
                            return value.replace(/[^-\d\.]/g, "");
                        }

var value = style[property];

if(value !== "auto" && getNumericalValue(value) !== "0") {
                            reporter.warn("An element that is positioned static has style." + property + "=" + value + " which is ignored due to the static positioning. The element will need to be positioned relative, so the style." + property + " will be set to 0. Element: ", element);
                            element.style[property] = 0;
                        }
                    };

//Check so that there are no accidental styles that will make the element styled differently now that is is relative.
                    //If there are any, set them to 0 (this should be okay with the user since the style properties did nothing before [since the element was positioned static] anyway).
                    removeRelativeStyles(reporter, element, style, "top");
                    removeRelativeStyles(reporter, element, style, "right");
                    removeRelativeStyles(reporter, element, style, "bottom");
                    removeRelativeStyles(reporter, element, style, "left");
                }
            }

function getLeftTopBottomRightCssText(left, top, bottom, right) {
                left = (!left ? "0" : (left + "px"));
                top = (!top ? "0" : (top + "px"));
                bottom = (!bottom ? "0" : (bottom + "px"));
                right = (!right ? "0" : (right + "px"));

return ["left: " + left, "top: " + top, "right: " + right, "bottom: " + bottom];
            }

debug("Injecting elements");

if (!getState(element)) {
                debug("Aborting because element has been uninstalled");
                return;
            }

alterPositionStyles();

var rootContainer = getState(element).container;

if (!rootContainer) {
                rootContainer = injectContainerElement();
            }

// Due to this WebKit bug https://bugs.webkit.org/show_bug.cgi?id=80808 (currently fixed in Blink, but still present in WebKit browsers such as Safari),
            // we need to inject two containers, one that is width/height 100% and another that is left/top -1px so that the final container always is 1x1 pixels bigger than
            // the targeted element.
            // When the bug is resolved, "containerContainer" may be removed.

// The outer container can occasionally be less wide than the targeted when inside inline elements element in WebKit (see https://bugs.webkit.org/show_bug.cgi?id=152980).
            // This should be no problem since the inner container either way makes sure the injected scroll elements are at least 1x1 px.

var scrollbarWidth          = scrollbarSizes.width;
            var scrollbarHeight         = scrollbarSizes.height;
            var containerContainerStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: hidden", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%", "left: 0px", "top: 0px"]);
            var containerStyle          = buildCssTextString(["position: absolute", "flex: none", "overflow: hidden", "z-index: -1", "visibility: hidden"].concat(getLeftTopBottomRightCssText(-(1 + scrollbarWidth), -(1 + scrollbarHeight), -scrollbarHeight, -scrollbarWidth)));
            var expandStyle             = buildCssTextString(["position: absolute", "flex: none", "overflow: scroll", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%"]);
            var shrinkStyle             = buildCssTextString(["position: absolute", "flex: none", "overflow: scroll", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%"]);
            var expandChildStyle        = buildCssTextString(["position: absolute", "left: 0", "top: 0"]);
            var shrinkChildStyle        = buildCssTextString(["position: absolute", "width: 200%", "height: 200%"]);

var containerContainer      = document.createElement("div");
            var container               = document.createElement("div");
            var expand                  = document.createElement("div");
            var expandChild             = document.createElement("div");
            var shrink                  = document.createElement("div");
            var shrinkChild             = document.createElement("div");

// Some browsers choke on the resize system being rtl, so force it to ltr. https://github.com/wnr/element-resize-detector/issues/56
            // However, dir should not be set on the top level container as it alters the dimensions of the target element in some browsers.
            containerContainer.dir              = "ltr";

containerContainer.style.cssText    = containerContainerStyle;
            containerContainer.className        = detectionContainerClass;
            container.className                 = detectionContainerClass;
            container.style.cssText             = containerStyle;
            expand.style.cssText                = expandStyle;
            expandChild.style.cssText           = expandChildStyle;
            shrink.style.cssText                = shrinkStyle;
            shrinkChild.style.cssText           = shrinkChildStyle;

expand.appendChild(expandChild);
            shrink.appendChild(shrinkChild);
            container.appendChild(expand);
            container.appendChild(shrink);
            containerContainer.appendChild(container);
            rootContainer.appendChild(containerContainer);

addEvent(expand, "scroll", onExpandScroll);
            addEvent(shrink, "scroll", onShrinkScroll);

// Store the event handlers here so that they may be removed when uninstall is called.
            // See uninstall function for an explanation why it is needed.
            getState(element).onExpandScroll = onExpandScroll;
            getState(element).onShrinkScroll = onShrinkScroll;
        }

function registerListenersAndPositionElements() {
            function updateChildSizes(element, width, height) {
                var expandChild             = getExpandChildElement(element);
                var expandWidth             = getExpandWidth(width);
                var expandHeight            = getExpandHeight(height);
                expandChild.style.setProperty("width", expandWidth + "px", options.important ? "important" : "");
                expandChild.style.setProperty("height", expandHeight + "px", options.important ? "important" : "");
            }

function updateDetectorElements(done) {
                var width           = element.offsetWidth;
                var height          = element.offsetHeight;

// Check whether the size has actually changed since last time the algorithm ran. If not, some steps may be skipped.
                var sizeChanged = width !== getState(element).lastWidth || height !== getState(element).lastHeight;

debug("Storing current size", width, height);

// Store the size of the element sync here, so that multiple scroll events may be ignored in the event listeners.
                // Otherwise the if-check in handleScroll is useless.
                storeCurrentSize(element, width, height);

// Since we delay the processing of the batch, there is a risk that uninstall has been called before the batch gets to execute.
                // Since there is no way to cancel the fn executions, we need to add an uninstall guard to all fns of the batch.

batchProcessor.add(0, function performUpdateChildSizes() {
                    if (!sizeChanged) {
                        return;
                    }

if (!getState(element)) {
                        debug("Aborting because element has been uninstalled");
                        return;
                    }

if (!areElementsInjected()) {
                        debug("Aborting because element container has not been initialized");
                        return;
                    }

if (options.debug) {
                        var w = element.offsetWidth;
                        var h = element.offsetHeight;

if (w !== width || h !== height) {
                            reporter.warn(idHandler.get(element), "Scroll: Size changed before updating detector elements.");
                        }
                    }

updateChildSizes(element, width, height);
                });

batchProcessor.add(1, function updateScrollbars() {
                    // This function needs to be invoked event though the size is unchanged. The element could have been resized very quickly and then
                    // been restored to the original size, which will have changed the scrollbar positions.

if (!getState(element)) {
                        debug("Aborting because element has been uninstalled");
                        return;
                    }

if (!areElementsInjected()) {
                        debug("Aborting because element container has not been initialized");
                        return;
                    }

positionScrollbars(element, width, height);
                });

if (sizeChanged && done) {
                    batchProcessor.add(2, function () {
                        if (!getState(element)) {
                            debug("Aborting because element has been uninstalled");
                            return;
                        }

if (!areElementsInjected()) {
                          debug("Aborting because element container has not been initialized");
                          return;
                        }

done();
                    });
                }
            }

function areElementsInjected() {
                return !!getState(element).container;
            }

function notifyListenersIfNeeded() {
                function isFirstNotify() {
                    return getState(element).lastNotifiedWidth === undefined;
                }

debug("notifyListenersIfNeeded invoked");

var state = getState(element);

// Don't notify if the current size is the start size, and this is the first notification.
                if (isFirstNotify() && state.lastWidth === state.startSize.width && state.lastHeight === state.startSize.height) {
                    return debug("Not notifying: Size is the same as the start size, and there has been no notification yet.");
                }

// Don't notify if the size already has been notified.
                if (state.lastWidth === state.lastNotifiedWidth && state.lastHeight === state.lastNotifiedHeight) {
                    return debug("Not notifying: Size already notified");
                }

debug("Current size not notified, notifying...");
                state.lastNotifiedWidth = state.lastWidth;
                state.lastNotifiedHeight = state.lastHeight;
                forEach(getState(element).listeners, function (listener) {
                    listener(element);
                });
            }

function handleRender() {
                debug("startanimation triggered.");

if (isUnrendered(element)) {
                    debug("Ignoring since element is still unrendered...");
                    return;
                }

debug("Element rendered.");
                var expand = getExpandElement(element);
                var shrink = getShrinkElement(element);
                if (expand.scrollLeft === 0 || expand.scrollTop === 0 || shrink.scrollLeft === 0 || shrink.scrollTop === 0) {
                    debug("Scrollbars out of sync. Updating detector elements...");
                    updateDetectorElements(notifyListenersIfNeeded);
                }
            }

function handleScroll() {
                debug("Scroll detected.");

if (isUnrendered(element)) {
                    // Element is still unrendered. Skip this scroll event.
                    debug("Scroll event fired while unrendered. Ignoring...");
                    return;
                }

updateDetectorElements(notifyListenersIfNeeded);
            }

debug("registerListenersAndPositionElements invoked.");

if (!getState(element)) {
                debug("Aborting because element has been uninstalled");
                return;
            }

getState(element).onRendered = handleRender;
            getState(element).onExpand = handleScroll;
            getState(element).onShrink = handleScroll;

var style = getState(element).style;
            updateChildSizes(element, style.width, style.height);
        }

function finalizeDomMutation() {
            debug("finalizeDomMutation invoked.");

if (!getState(element)) {
                debug("Aborting because element has been uninstalled");
                return;
            }

var style = getState(element).style;
            storeCurrentSize(element, style.width, style.height);
            positionScrollbars(element, style.width, style.height);
        }

function ready() {
            callback(element);
        }

function install() {
            debug("Installing...");
            initListeners();
            storeStartSize();

batchProcessor.add(0, storeStyle);
            batchProcessor.add(1, injectScrollElements);
            batchProcessor.add(2, registerListenersAndPositionElements);
            batchProcessor.add(3, finalizeDomMutation);
            batchProcessor.add(4, ready);
        }

debug("Making detectable...");

if (isDetached(element)) {
            debug("Element is detached");

injectContainerElement();

debug("Waiting until element is attached...");

getState(element).onRendered = function () {
                debug("Element is now attached");
                install();
            };
        } else {
            install();
        }
    }

function uninstall(element) {
        var state = getState(element);

if (!state) {
            // Uninstall has been called on a non-erd element.
            return;
        }

// Uninstall may have been called in the following scenarios:
        // (1) Right between the sync code and async batch (here state.busy = true, but nothing have been registered or injected).
        // (2) In the ready callback of the last level of the batch by another element (here, state.busy = true, but all the stuff has been injected).
        // (3) After the installation process (here, state.busy = false and all the stuff has been injected).
        // So to be on the safe side, let's check for each thing before removing.

// We need to remove the event listeners, because otherwise the event might fire on an uninstall element which results in an error when trying to get the state of the element.
        state.onExpandScroll && removeEvent(getExpandElement(element), "scroll", state.onExpandScroll);
        state.onShrinkScroll && removeEvent(getShrinkElement(element), "scroll", state.onShrinkScroll);
        state.onAnimationStart && removeEvent(state.container, "animationstart", state.onAnimationStart);

state.container && element.removeChild(state.container);
    }

return {
        makeDetectable: makeDetectable,
        addListener: addListener,
        uninstall: uninstall,
        initDocument: initDocument
    };
};

/***/ }),
/* 871 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var forEach                 = __webpack_require__(404).forEach;
var elementUtilsMaker       = __webpack_require__(872);
var listenerHandlerMaker    = __webpack_require__(875);
var idGeneratorMaker        = __webpack_require__(873);
var idHandlerMaker          = __webpack_require__(874);
var reporterMaker           = __webpack_require__(876);
var browserDetector         = __webpack_require__(403);
var batchProcessorMaker     = __webpack_require__(787);
var stateHandler            = __webpack_require__(877);

//Detection strategies.
var objectStrategyMaker     = __webpack_require__(869);
var scrollStrategyMaker     = __webpack_require__(870);

function isCollection(obj) {
    return Array.isArray(obj) || obj.length !== undefined;
}

function isElement(obj) {
    return obj && obj.nodeType === 1;
}

/**
 * @typedef idHandler
 * @type {object}
 * @property {function} get Gets the resize detector id of the element.
 * @property {function} set Generate and sets the resize detector id of the element.
 */

/**
 * @typedef Options
 * @type {object}
 * @property {boolean} callOnAdd    Determines if listeners should be called when they are getting added.
                                    Default is true. If true, the listener is guaranteed to be called when it has been added.
                                    If false, the listener will not be guarenteed to be called when it has been added (does not prevent it from being called).
 * @property {idHandler} idHandler  A custom id handler that is responsible for generating, setting and retrieving id's for elements.
                                    If not provided, a default id handler will be used.
 * @property {reporter} reporter    A custom reporter that handles reporting logs, warnings and errors.
                                    If not provided, a default id handler will be used.
                                    If set to false, then nothing will be reported.
 * @property {boolean} debug        If set to true, the the system will report debug messages as default for the listenTo method.
 */

/**
 * Creates an element resize detector instance.
 * @public
 * @param {Options?} options Optional global options object that will decide how this instance will work.
 */
module.exports = function(options) {
    options = options || {};

//idHandler is currently not an option to the listenTo function, so it should not be added to globalOptions.
    var idHandler;

if (options.idHandler) {
        // To maintain compatability with idHandler.get(element, readonly), make sure to wrap the given idHandler
        // so that readonly flag always is true when it's used here. This may be removed next major version bump.
        idHandler = {
            get: function (element) { return options.idHandler.get(element, true); },
            set: options.idHandler.set
        };
    } else {
        var idGenerator = idGeneratorMaker();
        var defaultIdHandler = idHandlerMaker({
            idGenerator: idGenerator,
            stateHandler: stateHandler
        });
        idHandler = defaultIdHandler;
    }

//reporter is currently not an option to the listenTo function, so it should not be added to globalOptions.
    var reporter = options.reporter;

if(!reporter) {
        //If options.reporter is false, then the reporter should be quiet.
        var quiet = reporter === false;
        reporter = reporterMaker(quiet);
    }

//batchProcessor is currently not an option to the listenTo function, so it should not be added to globalOptions.
    var batchProcessor = getOption(options, "batchProcessor", batchProcessorMaker({ reporter: reporter }));

//Options to be used as default for the listenTo function.
    var globalOptions = {};
    globalOptions.callOnAdd     = !!getOption(options, "callOnAdd", true);
    globalOptions.debug         = !!getOption(options, "debug", false);

var eventListenerHandler    = listenerHandlerMaker(idHandler);
    var elementUtils            = elementUtilsMaker({
        stateHandler: stateHandler
    });

//The detection strategy to be used.
    var detectionStrategy;
    var desiredStrategy = getOption(options, "strategy", "object");
    var importantCssRules = getOption(options, "important", false);
    var strategyOptions = {
        reporter: reporter,
        batchProcessor: batchProcessor,
        stateHandler: stateHandler,
        idHandler: idHandler,
        important: importantCssRules
    };

if(desiredStrategy === "scroll") {
        if (browserDetector.isLegacyOpera()) {
            reporter.warn("Scroll strategy is not supported on legacy Opera. Changing to object strategy.");
            desiredStrategy = "object";
        } else if (browserDetector.isIE(9)) {
            reporter.warn("Scroll strategy is not supported on IE9. Changing to object strategy.");
            desiredStrategy = "object";
        }
    }

if(desiredStrategy === "scroll") {
        detectionStrategy = scrollStrategyMaker(strategyOptions);
    } else if(desiredStrategy === "object") {
        detectionStrategy = objectStrategyMaker(strategyOptions);
    } else {
        throw new Error("Invalid strategy name: " + desiredStrategy);
    }

//Calls can be made to listenTo with elements that are still being installed.
    //Also, same elements can occur in the elements list in the listenTo function.
    //With this map, the ready callbacks can be synchronized between the calls
    //so that the ready callback can always be called when an element is ready - even if
    //it wasn't installed from the function itself.
    var onReadyCallbacks = {};

/**
     * Makes the given elements resize-detectable and starts listening to resize events on the elements. Calls the event callback for each event for each element.
     * @public
     * @param {Options?} options Optional options object. These options will override the global options. Some options may not be overriden, such as idHandler.
     * @param {element[]|element} elements The given array of elements to detect resize events of. Single element is also valid.
     * @param {function} listener The callback to be executed for each resize event for each element.
     */
    function listenTo(options, elements, listener) {
        function onResizeCallback(element) {
            var listeners = eventListenerHandler.get(element);
            forEach(listeners, function callListenerProxy(listener) {
                listener(element);
            });
        }

function addListener(callOnAdd, element, listener) {
            eventListenerHandler.add(element, listener);

if(callOnAdd) {
                listener(element);
            }
        }

//Options object may be omitted.
        if(!listener) {
            listener = elements;
            elements = options;
            options = {};
        }

if(!elements) {
            throw new Error("At least one element required.");
        }

if(!listener) {
            throw new Error("Listener required.");
        }

if (isElement(elements)) {
            // A single element has been passed in.
            elements = [elements];
        } else if (isCollection(elements)) {
            // Convert collection to array for plugins.
            // TODO: May want to check so that all the elements in the collection are valid elements.
            elements = toArray(elements);
        } else {
            return reporter.error("Invalid arguments. Must be a DOM element or a collection of DOM elements.");
        }

var elementsReady = 0;

var callOnAdd = getOption(options, "callOnAdd", globalOptions.callOnAdd);
        var onReadyCallback = getOption(options, "onReady", function noop() {});
        var debug = getOption(options, "debug", globalOptions.debug);

forEach(elements, function attachListenerToElement(element) {
            if (!stateHandler.getState(element)) {
                stateHandler.initState(element);
                idHandler.set(element);
            }

var id = idHandler.get(element);

debug && reporter.log("Attaching listener to element", id, element);

if(!elementUtils.isDetectable(element)) {
                debug && reporter.log(id, "Not detectable.");
                if(elementUtils.isBusy(element)) {
                    debug && reporter.log(id, "System busy making it detectable");

//The element is being prepared to be detectable. Do not make it detectable.
                    //Just add the listener, because the element will soon be detectable.
                    addListener(callOnAdd, element, listener);
                    onReadyCallbacks[id] = onReadyCallbacks[id] || [];
                    onReadyCallbacks[id].push(function onReady() {
                        elementsReady++;

if(elementsReady === elements.length) {
                            onReadyCallback();
                        }
                    });
                    return;
                }

debug && reporter.log(id, "Making detectable...");
                //The element is not prepared to be detectable, so do prepare it and add a listener to it.
                elementUtils.markBusy(element, true);
                return detectionStrategy.makeDetectable({ debug: debug, important: importantCssRules }, element, function onElementDetectable(element) {
                    debug && reporter.log(id, "onElementDetectable");

if (stateHandler.getState(element)) {
                        elementUtils.markAsDetectable(element);
                        elementUtils.markBusy(element, false);
                        detectionStrategy.addListener(element, onResizeCallback);
                        addListener(callOnAdd, element, listener);

// Since the element size might have changed since the call to "listenTo", we need to check for this change,
                        // so that a resize event may be emitted.
                        // Having the startSize object is optional (since it does not make sense in some cases such as unrendered elements), so check for its existance before.
                        // Also, check the state existance before since the element may have been uninstalled in the installation process.
                        var state = stateHandler.getState(element);
                        if (state && state.startSize) {
                            var width = element.offsetWidth;
                            var height = element.offsetHeight;
                            if (state.startSize.width !== width || state.startSize.height !== height) {
                                onResizeCallback(element);
                            }
                        }

if(onReadyCallbacks[id]) {
                            forEach(onReadyCallbacks[id], function(callback) {
                                callback();
                            });
                        }
                    } else {
                        // The element has been unisntalled before being detectable.
                        debug && reporter.log(id, "Element uninstalled before being detectable.");
                    }

delete onReadyCallbacks[id];

elementsReady++;
                    if(elementsReady === elements.length) {
                        onReadyCallback();
                    }
                });
            }

debug && reporter.log(id, "Already detecable, adding listener.");

//The element has been prepared to be detectable and is ready to be listened to.
            addListener(callOnAdd, element, listener);
            elementsReady++;
        });

if(elementsReady === elements.length) {
            onReadyCallback();
        }
    }

function uninstall(elements) {
        if(!elements) {
            return reporter.error("At least one element is required.");
        }

forEach(elements, function (element) {
            eventListenerHandler.removeAllListeners(element);
            detectionStrategy.uninstall(element);
            stateHandler.cleanState(element);
        });
    }

function initDocument(targetDocument) {
        detectionStrategy.initDocument && detectionStrategy.initDocument(targetDocument);
    }

return {
        listenTo: listenTo,
        removeListener: eventListenerHandler.removeListener,
        removeAllListeners: eventListenerHandler.removeAllListeners,
        uninstall: uninstall,
        initDocument: initDocument
    };
};

function getOption(options, name, defaultValue) {
    var value = options[name];

if((value === undefined || value === null) && defaultValue !== undefined) {
        return defaultValue;
    }

return value;
}

/***/ }),
/* 872 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function(options) {
    var getState = options.stateHandler.getState;

/**
     * Tells if the element has been made detectable and ready to be listened for resize events.
     * @public
     * @param {element} The element to check.
     * @returns {boolean} True or false depending on if the element is detectable or not.
     */
    function isDetectable(element) {
        var state = getState(element);
        return state && !!state.isDetectable;
    }

/**
     * Marks the element that it has been made detectable and ready to be listened for resize events.
     * @public
     * @param {element} The element to mark.
     */
    function markAsDetectable(element) {
        getState(element).isDetectable = true;
    }

/**
     * Tells if the element is busy or not.
     * @public
     * @param {element} The element to check.
     * @returns {boolean} True or false depending on if the element is busy or not.
     */
    function isBusy(element) {
        return !!getState(element).busy;
    }

/**
     * Marks the object is busy and should not be made detectable.
     * @public
     * @param {element} element The element to mark.
     * @param {boolean} busy If the element is busy or not.
     */
    function markBusy(element, busy) {
        getState(element).busy = !!busy;
    }

return {
        isDetectable: isDetectable,
        markAsDetectable: markAsDetectable,
        isBusy: isBusy,
        markBusy: markBusy
    };
};

/***/ }),
/* 873 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function() {
    var idCount = 1;

/**
     * Generates a new unique id in the context.
     * @public
     * @returns {number} A unique id in the context.
     */
    function generate() {
        return idCount++;
    }

return {
        generate: generate
    };
};

/***/ }),
/* 874 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function(options) {
    var idGenerator     = options.idGenerator;
    var getState        = options.stateHandler.getState;

/**
     * Gets the resize detector id of the element.
     * @public
     * @param {element} element The target element to get the id of.
     * @returns {string|number|null} The id of the element. Null if it has no id.
     */
    function getId(element) {
        var state = getState(element);

if (state && state.id !== undefined) {
            return state.id;
        }

return null;
    }

/**
     * Sets the resize detector id of the element. Requires the element to have a resize detector state initialized.
     * @public
     * @param {element} element The target element to set the id of.
     * @returns {string|number|null} The id of the element.
     */
    function setId(element) {
        var state = getState(element);

if (!state) {
            throw new Error("setId required the element to have a resize detection state.");
        }

var id = idGenerator.generate();

state.id = id;

return id;
    }

return {
        get: getId,
        set: setId
    };
};

/***/ }),
/* 875 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function(idHandler) {
    var eventListeners = {};

/**
     * Gets all listeners for the given element.
     * @public
     * @param {element} element The element to get all listeners for.
     * @returns All listeners for the given element.
     */
    function getListeners(element) {
        var id = idHandler.get(element);

if (id === undefined) {
            return [];
        }

return eventListeners[id] || [];
    }

/**
     * Stores the given listener for the given element. Will not actually add the listener to the element.
     * @public
     * @param {element} element The element that should have the listener added.
     * @param {function} listener The callback that the element has added.
     */
    function addListener(element, listener) {
        var id = idHandler.get(element);

if(!eventListeners[id]) {
            eventListeners[id] = [];
        }

eventListeners[id].push(listener);
    }

function removeAllListeners(element) {
      var listeners = getListeners(element);
      if (!listeners) { return; }
      listeners.length = 0;
    }

return {
        get: getListeners,
        add: addListener,
        removeListener: removeListener,
        removeAllListeners: removeAllListeners
    };
};

/***/ }),
/* 876 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/* global console: false */

/**
 * Reporter that handles the reporting of logs, warnings and errors.
 * @public
 * @param {boolean} quiet Tells if the reporter should be quiet or not.
 */
module.exports = function(quiet) {
    function noop() {
        //Does nothing.
    }

var reporter = {
        log: noop,
        warn: noop,
        error: noop
    };

if(!quiet && window.console) {
        var attachFunction = function(reporter, name) {
            //The proxy is needed to be able to call the method with the console context,
            //since we cannot use bind.
            reporter[name] = function reporterProxy() {
                var f = console[name];
                if (f.apply) { //IE9 does not support console.log.apply :)
                    f.apply(console, arguments);
                } else {
                    for (var i = 0; i < arguments.length; i++) {
                        f(arguments[i]);
                    }
                }
            };
        };

attachFunction(reporter, "log");
        attachFunction(reporter, "warn");
        attachFunction(reporter, "error");
    }

return reporter;
};

/***/ }),
/* 877 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var prop = "_erd";

function initState(element) {
    element[prop] = {};
    return getState(element);
}

function getState(element) {
    return element[prop];
}

function cleanState(element) {
    delete element[prop];
}

module.exports = {
    initState: initState,
    getState: getState,
    cleanState: cleanState
};

/***/ }),
/* 878 */
/***/ (function(module, exports, __webpack_require__) {

var QueryHandler = __webpack_require__(880);
var each = __webpack_require__(405).each;

/**
 * Represents a single media query, manages it's state and registered handlers for this query
 *
 * @constructor
 * @param {string} query the media query string
 * @param {boolean} [isUnconditional=false] whether the media query should run regardless of whether the conditions are met. Primarily for helping older browsers deal with mobile-first design
 */
function MediaQuery(query, isUnconditional) {
    this.query = query;
    this.isUnconditional = isUnconditional;
    this.handlers = [];
    this.mql = window.matchMedia(query);

var self = this;
    this.listener = function(mql) {
        // Chrome passes an MediaQueryListEvent object, while other browsers pass MediaQueryList directly
        self.mql = mql.currentTarget || mql;
        self.assess();
    };
    this.mql.addListener(this.listener);
}

MediaQuery.prototype = {

constuctor : MediaQuery,

/**
     * add a handler for this query, triggering if already active
     *
     * @param {object} handler
     * @param {function} handler.match callback for when query is activated
     * @param {function} [handler.unmatch] callback for when query is deactivated
     * @param {function} [handler.setup] callback for immediate execution when a query handler is registered
     * @param {boolean} [handler.deferSetup=false] should the setup callback be deferred until the first time the handler is matched?
     */
    addHandler : function(handler) {
        var qh = new QueryHandler(handler);
        this.handlers.push(qh);

this.matches() && qh.on();
    },

/**
     * removes the given handler from the collection, and calls it's destroy methods
     *
     * @param {object || function} handler the handler to remove
     */
    removeHandler : function(handler) {
        var handlers = this.handlers;
        each(handlers, function(h, i) {
            if(h.equals(handler)) {
                h.destroy();
                return !handlers.splice(i,1); //remove from array and exit each early
            }
        });
    },

/**
     * Determine whether the media query should be considered a match
     *
     * @return {Boolean} true if media query can be considered a match, false otherwise
     */
    matches : function() {
        return this.mql.matches || this.isUnconditional;
    },

/**
     * Clears all handlers and unbinds events
     */
    clear : function() {
        each(this.handlers, function(handler) {
            handler.destroy();
        });
        this.mql.removeListener(this.listener);
        this.handlers.length = 0; //clear array
    },

/*
        * Assesses the query, turning on all handlers if it matches, turning them off if it doesn't match
        */
    assess : function() {
        var action = this.matches() ? 'on' : 'off';

each(this.handlers, function(handler) {
            handler[action]();
        });
    }
};

module.exports = MediaQuery;

/***/ }),
/* 879 */
/***/ (function(module, exports, __webpack_require__) {

var MediaQuery = __webpack_require__(878);
var Util = __webpack_require__(405);
var each = Util.each;
var isFunction = Util.isFunction;
var isArray = Util.isArray;

/**
 * Allows for registration of query handlers.
 * Manages the query handler's state and is responsible for wiring up browser events
 *
 * @constructor
 */
function MediaQueryDispatch () {
    if(!window.matchMedia) {
        throw new Error('matchMedia not present, legacy browsers require a polyfill');
    }

this.queries = {};
    this.browserIsIncapable = !window.matchMedia('only all').matches;
}

MediaQueryDispatch.prototype = {

constructor : MediaQueryDispatch,

/**
     * Registers a handler for the given media query
     *
     * @param {string} q the media query
     * @param {object || Array || Function} options either a single query handler object, a function, or an array of query handlers
     * @param {function} options.match fired when query matched
     * @param {function} [options.unmatch] fired when a query is no longer matched
     * @param {function} [options.setup] fired when handler first triggered
     * @param {boolean} [options.deferSetup=false] whether setup should be run immediately or deferred until query is first matched
     * @param {boolean} [shouldDegrade=false] whether this particular media query should always run on incapable browsers
     */
    register : function(q, options, shouldDegrade) {
        var queries         = this.queries,
            isUnconditional = shouldDegrade && this.browserIsIncapable;

if(!queries[q]) {
            queries[q] = new MediaQuery(q, isUnconditional);
        }

//normalise to object in an array
        if(isFunction(options)) {
            options = { match : options };
        }
        if(!isArray(options)) {
            options = [options];
        }
        each(options, function(handler) {
            if (isFunction(handler)) {
                handler = { match : handler };
            }
            queries[q].addHandler(handler);
        });

return this;
    },

/**
     * unregisters a query and all it's handlers, or a specific handler for a query
     *
     * @param {string} q the media query to target
     * @param {object || function} [handler] specific handler to unregister
     */
    unregister : function(q, handler) {
        var query = this.queries[q];

if(query) {
            if(handler) {
                query.removeHandler(handler);
            }
            else {
                query.clear();
                delete this.queries[q];
            }
        }

return this;
    }
};

module.exports = MediaQueryDispatch;

/***/ }),
/* 880 */
/***/ (function(module, exports) {

/**
 * Delegate to handle a media query being matched and unmatched.
 *
 * @param {object} options
 * @param {function} options.match callback for when the media query is matched
 * @param {function} [options.unmatch] callback for when the media query is unmatched
 * @param {function} [options.setup] one-time callback triggered the first time a query is matched
 * @param {boolean} [options.deferSetup=false] should the setup callback be run immediately, rather than first time query is matched?
 * @constructor
 */
function QueryHandler(options) {
    this.options = options;
    !options.deferSetup && this.setup();
}

QueryHandler.prototype = {

constructor : QueryHandler,

/**
     * coordinates setup of the handler
     *
     * @function
     */
    setup : function() {
        if(this.options.setup) {
            this.options.setup();
        }
        this.initialised = true;
    },

/**
     * coordinates setup and triggering of the handler
     *
     * @function
     */
    on : function() {
        !this.initialised && this.setup();
        this.options.match && this.options.match();
    },

/**
     * coordinates the unmatch event for the handler
     *
     * @function
     */
    off : function() {
        this.options.unmatch && this.options.unmatch();
    },

/**
     * called when a handler is to be destroyed.
     * delegates to the destroy or unmatch callbacks, depending on availability.
     *
     * @function
     */
    destroy : function() {
        this.options.destroy ? this.options.destroy() : this.off();
    },

/**
     * determines equality by reference.
     * if object is supplied compare options, if function, compare match callback
     *
     * @function
     * @param {object || function} [target] the target for comparison
     */
    equals : function(target) {
        return this.options === target || this.options.match === target;
    }

};

module.exports = QueryHandler;

/***/ }),
/* 881 */
/***/ (function(module, exports, __webpack_require__) {

var MediaQueryDispatch = __webpack_require__(879);
module.exports = new MediaQueryDispatch();

/***/ }),
/* 882 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {module.exports = global["ReactSlick"] = __webpack_require__(1276);
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 883 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 884 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 885 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 886 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 887 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 888 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 889 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 890 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 891 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 892 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 893 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 894 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 895 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 896 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 897 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 898 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 899 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 900 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 901 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 902 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 903 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 904 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 905 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 906 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 907 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 908 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 909 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 910 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 911 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 912 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 913 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 914 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 915 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 916 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 917 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 918 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 919 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 920 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 921 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 922 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 923 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 924 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 925 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 926 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 927 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 928 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin

/***/ }),
/* 929 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _hyphenPattern = /-(.)/g;

/**
 * Camelcases a hyphenated string, for example:
 *
 *   > camelize('background-color')
 *   < "backgroundColor"
 *
 * @param {string} string
 * @return {string}
 */
function camelize(string) {
  return string.replace(_hyphenPattern, function (_, character) {
    return character.toUpperCase();
  });
}

module.exports = camelize;

/***/ }),
/* 930 */
/***/ (function(module, exports, __webpack_require__) {

var camelize = __webpack_require__(929);

var msPattern = /^-ms-/;

/**
 * Camelcases a hyphenated CSS property name, for example:
 *
 *   > camelizeStyleName('background-color')
 *   < "backgroundColor"
 *   > camelizeStyleName('-moz-transition')
 *   < "MozTransition"
 *   > camelizeStyleName('-ms-transition')
 *   < "msTransition"
 *
 * As Andi Smith suggests
 * (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
 * is converted to lowercase `ms`.
 *
 * @param {string} string
 * @return {string}
 */
function camelizeStyleName(string) {
  return camelize(string.replace(msPattern, 'ms-'));
}

module.exports = camelizeStyleName;

/***/ }),
/* 931 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */

var isTextNode = __webpack_require__(939);

/*eslint-disable no-bitwise */

/**
 * Checks if a given DOM node contains or is another DOM node.
 */
function containsNode(outerNode, innerNode) {
  if (!outerNode || !innerNode) {
    return false;
  } else if (outerNode === innerNode) {
    return true;
  } else if (isTextNode(outerNode)) {
    return false;
  } else if (isTextNode(innerNode)) {
    return containsNode(outerNode, innerNode.parentNode);
  } else if ('contains' in outerNode) {
    return outerNode.contains(innerNode);
  } else if (outerNode.compareDocumentPosition) {
    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
  } else {
    return false;
  }
}

module.exports = containsNode;

/***/ }),
/* 932 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

var invariant = __webpack_require__(19);

/**
 * Convert array-like objects to arrays.
 *
 * This API assumes the caller knows the contents of the data type. For less
 * well defined inputs use createArrayFromMixed.
 *
 * @param {object|function|filelist} obj
 * @return {array}
 */
function toArray(obj) {
  var length = obj.length;

// Some browsers builtin objects can report typeof 'function' (e.g. NodeList
  // in old versions of Safari).
  !(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;

!(typeof length === 'number') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;

!(length === 0 || length - 1 in obj) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;

!(typeof obj.callee !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object can\'t be `arguments`. Use rest params ' + '(function(...args) {}) or Array.from() instead.') : invariant(false) : void 0;

// Old IE doesn't give collections access to hasOwnProperty. Assume inputs
  // without method will throw during the slice call and skip straight to the
  // fallback.
  if (obj.hasOwnProperty) {
    try {
      return Array.prototype.slice.call(obj);
    } catch (e) {
      // IE < 9 does not support Array#slice on collections objects
    }
  }

// Fall back to copying key by key. This assumes all keys have a value,
  // so will not preserve sparsely populated inputs.
  var ret = Array(length);
  for (var ii = 0; ii < length; ii++) {
    ret[ii] = obj[ii];
  }
  return ret;
}

/**
 * Perform a heuristic test to determine if an object is "array-like".
 *
 *   A monk asked Joshu, a Zen master, "Has a dog Buddha nature?"
 *   Joshu replied: "Mu."
 *
 * This function determines if its argument has "array nature": it returns
 * true if the argument is an actual array, an `arguments' object, or an
 * HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).
 *
 * It will return false for other array-like objects like Filelist.
 *
 * @param {*} obj
 * @return {boolean}
 */
function hasArrayNature(obj) {
  return (
    // not null/false
    !!obj && (
    // arrays are objects, NodeLists are functions in Safari
    typeof obj == 'object' || typeof obj == 'function') &&
    // quacks like an array
    'length' in obj &&
    // not window
    !('setInterval' in obj) &&
    // no DOM node should be considered an array-like
    // a 'select' element has 'length' and 'item' properties on IE8
    typeof obj.nodeType != 'number' && (
    // a real array
    Array.isArray(obj) ||
    // arguments
    'callee' in obj ||
    // HTMLCollection/NodeList
    'item' in obj)
  );
}

/**
 * Ensure that the argument is an array by wrapping it in an array if it is not.
 * Creates a copy of the argument if it is already an array.
 *
 * This is mostly useful idiomatically:
 *
 *   var createArrayFromMixed = require('createArrayFromMixed');
 *
 *   function takesOneOrMoreThings(things) {
 *     things = createArrayFromMixed(things);
 *     ...
 *   }
 *
 * This allows you to treat `things' as an array, but accept scalars in the API.
 *
 * If you need to convert an array-like object, like `arguments`, into an array
 * use toArray instead.
 *
 * @param {*} obj
 * @return {array}
 */
function createArrayFromMixed(obj) {
  if (!hasArrayNature(obj)) {
    return [obj];
  } else if (Array.isArray(obj)) {
    return obj.slice();
  } else {
    return toArray(obj);
  }
}

module.exports = createArrayFromMixed;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 933 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

/*eslint-disable fb-www/unsafe-html*/

var ExecutionEnvironment = __webpack_require__(30);

var createArrayFromMixed = __webpack_require__(932);
var getMarkupWrap = __webpack_require__(934);
var invariant = __webpack_require__(19);

/**
 * Dummy container used to render all markup.
 */
var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;

/**
 * Pattern used by `getNodeName`.
 */
var nodeNamePattern = /^\s*<(\w+)/;

/**
 * Extracts the `nodeName` of the first element in a string of markup.
 *
 * @param {string} markup String of markup.
 * @return {?string} Node name of the supplied markup.
 */
function getNodeName(markup) {
  var nodeNameMatch = markup.match(nodeNamePattern);
  return nodeNameMatch && nodeNameMatch[1].toLowerCase();
}

/**
 * Creates an array containing the nodes rendered from the supplied markup. The
 * optionally supplied `handleScript` function will be invoked once for each
 * <script> element that is rendered. If no `handleScript` function is supplied,
 * an exception is thrown if any <script> elements are rendered.
 *
 * @param {string} markup A string of valid HTML markup.
 * @param {?function} handleScript Invoked once for each rendered <script>.
 * @return {array<DOMElement|DOMTextNode>} An array of rendered nodes.
 */
function createNodesFromMarkup(markup, handleScript) {
  var node = dummyNode;
  !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup dummy not initialized') : invariant(false) : void 0;
  var nodeName = getNodeName(markup);

var wrap = nodeName && getMarkupWrap(nodeName);
  if (wrap) {
    node.innerHTML = wrap[1] + markup + wrap[2];

var wrapDepth = wrap[0];
    while (wrapDepth--) {
      node = node.lastChild;
    }
  } else {
    node.innerHTML = markup;
  }

var scripts = node.getElementsByTagName('script');
  if (scripts.length) {
    !handleScript ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup(...): Unexpected <script> element rendered.') : invariant(false) : void 0;
    createArrayFromMixed(scripts).forEach(handleScript);
  }

var nodes = Array.from(node.childNodes);
  while (node.lastChild) {
    node.removeChild(node.lastChild);
  }
  return nodes;
}

module.exports = createNodesFromMarkup;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 934 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

/*eslint-disable fb-www/unsafe-html */

var ExecutionEnvironment = __webpack_require__(30);

var invariant = __webpack_require__(19);

/**
 * Dummy container used to detect which wraps are necessary.
 */
var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;

/**
 * Some browsers cannot use `innerHTML` to render certain elements standalone,
 * so we wrap them, render the wrapped nodes, then extract the desired node.
 *
 * In IE8, certain elements cannot render alone, so wrap all elements ('*').
 */

var shouldWrap = {};

var selectWrap = [1, '<select multiple="true">', '</select>'];
var tableWrap = [1, '<table>', '</table>'];
var trWrap = [3, '<table><tbody><tr>', '</tr></tbody></table>'];

var svgWrap = [1, '<svg xmlns="http://www.w3.org/2000/svg">', '</svg>'];

var markupWrap = {
  '*': [1, '?<div>', '</div>'],

'area': [1, '<map>', '</map>'],
  'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
  'legend': [1, '<fieldset>', '</fieldset>'],
  'param': [1, '<object>', '</object>'],
  'tr': [2, '<table><tbody>', '</tbody></table>'],

'optgroup': selectWrap,
  'option': selectWrap,

'caption': tableWrap,
  'colgroup': tableWrap,
  'tbody': tableWrap,
  'tfoot': tableWrap,
  'thead': tableWrap,

'td': trWrap,
  'th': trWrap
};

// Initialize the SVG elements since we know they'll always need to be wrapped
// consistently. If they are created inside a <div> they will be initialized in
// the wrong namespace (and will not display).
var svgElements = ['circle', 'clipPath', 'defs', 'ellipse', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'text', 'tspan'];
svgElements.forEach(function (nodeName) {
  markupWrap[nodeName] = svgWrap;
  shouldWrap[nodeName] = true;
});

/**
 * Gets the markup wrap configuration for the supplied `nodeName`.
 *
 * NOTE: This lazily detects which wraps are necessary for the current browser.
 *
 * @param {string} nodeName Lowercase `nodeName`.
 * @return {?array} Markup wrap configuration, if applicable.
 */
function getMarkupWrap(nodeName) {
  !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Markup wrapping node not initialized') : invariant(false) : void 0;
  if (!markupWrap.hasOwnProperty(nodeName)) {
    nodeName = '*';
  }
  if (!shouldWrap.hasOwnProperty(nodeName)) {
    if (nodeName === '*') {
      dummyNode.innerHTML = '<link />';
    } else {
      dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';
    }
    shouldWrap[nodeName] = !dummyNode.firstChild;
  }
  return shouldWrap[nodeName] ? markupWrap[nodeName] : null;
}

module.exports = getMarkupWrap;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 935 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * Gets the scroll position of the supplied element or window.
 *
 * The return values are unbounded, unlike `getScrollPosition`. This means they
 * may be negative or exceed the element boundaries (which is possible using
 * inertial scrolling).
 *
 * @param {DOMWindow|DOMElement} scrollable
 * @return {object} Map with `x` and `y` keys.
 */

function getUnboundedScrollPosition(scrollable) {
  if (scrollable.Window && scrollable instanceof scrollable.Window) {
    return {
      x: scrollable.pageXOffset || scrollable.document.documentElement.scrollLeft,
      y: scrollable.pageYOffset || scrollable.document.documentElement.scrollTop
    };
  }
  return {
    x: scrollable.scrollLeft,
    y: scrollable.scrollTop
  };
}

module.exports = getUnboundedScrollPosition;

/***/ }),
/* 936 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _uppercasePattern = /([A-Z])/g;

/**
 * Hyphenates a camelcased string, for example:
 *
 *   > hyphenate('backgroundColor')
 *   < "background-color"
 *
 * For CSS style names, use `hyphenateStyleName` instead which works properly
 * with all vendor prefixes, including `ms`.
 *
 * @param {string} string
 * @return {string}
 */
function hyphenate(string) {
  return string.replace(_uppercasePattern, '-$1').toLowerCase();
}

module.exports = hyphenate;

/***/ }),
/* 937 */
/***/ (function(module, exports, __webpack_require__) {

var hyphenate = __webpack_require__(936);

var msPattern = /^ms-/;

/**
 * Hyphenates a camelcased CSS property name, for example:
 *
 *   > hyphenateStyleName('backgroundColor')
 *   < "background-color"
 *   > hyphenateStyleName('MozTransition')
 *   < "-moz-transition"
 *   > hyphenateStyleName('msTransition')
 *   < "-ms-transition"
 *
 * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
 * is converted to `-ms-`.
 *
 * @param {string} string
 * @return {string}
 */
function hyphenateStyleName(string) {
  return hyphenate(string).replace(msPattern, '-ms-');
}

module.exports = hyphenateStyleName;

/***/ }),
/* 938 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * @param {*} object The object to check.
 * @return {boolean} Whether or not the object is a DOM node.
 */
function isNode(object) {
  var doc = object ? object.ownerDocument || object : document;
  var defaultView = doc.defaultView || window;
  return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
}

module.exports = isNode;

/***/ }),
/* 939 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var isNode = __webpack_require__(938);

/**
 * @param {*} object The object to check.
 * @return {boolean} Whether or not the object is a DOM text node.
 */
function isTextNode(object) {
  return isNode(object) && object.nodeType == 3;
}

module.exports = isTextNode;

/***/ }),
/* 940 */
/***/ (function(module, exports, __webpack_require__) {

/**
 * Memoizes the return value of a function that accepts one string argument.
 */

module.exports = memoizeStringOnly;

/***/ }),
/* 941 */
/***/ (function(module, exports, __webpack_require__) {

var ExecutionEnvironment = __webpack_require__(30);

var performance;

if (ExecutionEnvironment.canUseDOM) {
  performance = window.performance || window.msPerformance || window.webkitPerformance;
}

module.exports = performance || {};

/***/ }),
/* 942 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var performance = __webpack_require__(941);

var performanceNow;

/**
 * Detect if we can use `window.performance.now()` and gracefully fallback to
 * `Date.now()` if it doesn't exist. We need to support Firefox < 15 for now
 * because of Facebook's testing infrastructure.
 */
if (performance.now) {
  performanceNow = function performanceNow() {
    return performance.now();
  };
} else {
  performanceNow = function performanceNow() {
    return Date.now();
  };
}

module.exports = performanceNow;

/***/ }),
/* 943 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
 * Fizzy UI utils v2.0.7
 * MIT license
 */

/*jshint browser: true, undef: true, unused: true, strict: true */

( function( window, factory ) {
  // universal module definition
  /*jshint strict: false */ /*globals define, module, require */

if ( true ) {
    // AMD
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
      __webpack_require__(845)
    ], __WEBPACK_AMD_DEFINE_RESULT__ = function( matchesSelector ) {
      return factory( window, matchesSelector );
    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if ( typeof module == 'object' && module.exports ) {
    // CommonJS
    module.exports = factory(
      window,
      require('desandro-matches-selector')
    );
  } else {
    // browser global
    window.fizzyUIUtils = factory(
      window,
      window.matchesSelector
    );
  }

}( window, function factory( window, matchesSelector ) {

'use strict';

var utils = {};

// ----- extend ----- //

// extends objects
utils.extend = function( a, b ) {
  for ( var prop in b ) {
    a[ prop ] = b[ prop ];
  }
  return a;
};

// ----- modulo ----- //

utils.modulo = function( num, div ) {
  return ( ( num % div ) + div ) % div;
};

// ----- makeArray ----- //

var arraySlice = Array.prototype.slice;

// turn element or nodeList into an array
utils.makeArray = function( obj ) {
  if ( Array.isArray( obj ) ) {
    // use object if already an array
    return obj;
  }
  // return empty array if undefined or null. #6
  if ( obj === null || obj === undefined ) {
    return [];
  }

var isArrayLike = typeof obj == 'object' && typeof obj.length == 'number';
  if ( isArrayLike ) {
    // convert nodeList to array
    return arraySlice.call( obj );
  }

// array of single index
  return [ obj ];
};

// ----- removeFrom ----- //

utils.removeFrom = function( ary, obj ) {
  var index = ary.indexOf( obj );
  if ( index != -1 ) {
    ary.splice( index, 1 );
  }
};

// ----- getParent ----- //

utils.getParent = function( elem, selector ) {
  while ( elem.parentNode && elem != document.body ) {
    elem = elem.parentNode;
    if ( matchesSelector( elem, selector ) ) {
      return elem;
    }
  }
};

// ----- getQueryElement ----- //

// use element as selector string
utils.getQueryElement = function( elem ) {
  if ( typeof elem == 'string' ) {
    return document.querySelector( elem );
  }
  return elem;
};

// ----- handleEvent ----- //

// enable .ontype to trigger from .addEventListener( elem, 'type' )
utils.handleEvent = function( event ) {
  var method = 'on' + event.type;
  if ( this[ method ] ) {
    this[ method ]( event );
  }
};

// ----- filterFindElements ----- //

utils.filterFindElements = function( elems, selector ) {
  // make array of elems
  elems = utils.makeArray( elems );
  var ffElems = [];

elems.forEach( function( elem ) {
    // check that elem is an actual element
    if ( !( elem instanceof HTMLElement ) ) {
      return;
    }
    // add elem if no selector
    if ( !selector ) {
      ffElems.push( elem );
      return;
    }
    // filter & find items if we have a selector
    // filter
    if ( matchesSelector( elem, selector ) ) {
      ffElems.push( elem );
    }
    // find children
    var childElems = elem.querySelectorAll( selector );
    // concat childElems to filterFound array
    for ( var i=0; i < childElems.length; i++ ) {
      ffElems.push( childElems[i] );
    }
  });

return ffElems;
};

// ----- debounceMethod ----- //

utils.debounceMethod = function( _class, methodName, threshold ) {
  threshold = threshold || 100;
  // original method
  var method = _class.prototype[ methodName ];
  var timeoutName = methodName + 'Timeout';

_class.prototype[ methodName ] = function() {
    var timeout = this[ timeoutName ];
    clearTimeout( timeout );

var args = arguments;
    var _this = this;
    this[ timeoutName ] = setTimeout( function() {
      method.apply( _this, args );
      delete _this[ timeoutName ];
    }, threshold );
  };
};

// ----- docReady ----- //

utils.docReady = function( callback ) {
  var readyState = document.readyState;
  if ( readyState == 'complete' || readyState == 'interactive' ) {
    // do async to allow for other scripts to run. metafizzy/flickity#441
    setTimeout( callback );
  } else {
    document.addEventListener( 'DOMContentLoaded', callback );
  }
};

// ----- htmlInit ----- //

// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
utils.toDashed = function( str ) {
  return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) {
    return $1 + '-' + $2;
  }).toLowerCase();
};

var console = window.console;
/**
 * allow user to initialize classes via [data-namespace] or .js-namespace class
 * htmlInit( Widget, 'widgetName' )
 * options are parsed from data-namespace-options
 */
utils.htmlInit = function( WidgetClass, namespace ) {
  utils.docReady( function() {
    var dashedNamespace = utils.toDashed( namespace );
    var dataAttr = 'data-' + dashedNamespace;
    var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' );
    var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace );
    var elems = utils.makeArray( dataAttrElems )
      .concat( utils.makeArray( jsDashElems ) );
    var dataOptionsAttr = dataAttr + '-options';
    var jQuery = window.jQuery;

elems.forEach( function( elem ) {
      var attr = elem.getAttribute( dataAttr ) ||
        elem.getAttribute( dataOptionsAttr );
      var options;
      try {
        options = attr && JSON.parse( attr );
      } catch ( error ) {
        // log error, do not initialize
        if ( console ) {
          console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className +
          ': ' + error );
        }
        return;
      }
      // initialize
      var instance = new WidgetClass( elem, options );
      // make available via $().data('namespace')
      if ( jQuery ) {
        jQuery.data( elem, namespace, instance );
      }
    });

});
};

// -----  ----- //

return utils;

}));

/***/ }),
/* 944 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/* eslint no-invalid-this: 1 */

var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
var slice = Array.prototype.slice;
var toStr = Object.prototype.toString;
var funcType = '[object Function]';

module.exports = function bind(that) {
    var target = this;
    if (typeof target !== 'function' || toStr.call(target) !== funcType) {
        throw new TypeError(ERROR_MESSAGE + target);
    }
    var args = slice.call(arguments, 1);

var bound;
    var binder = function () {
        if (this instanceof bound) {
            var result = target.apply(
                this,
                args.concat(slice.call(arguments))
            );
            if (Object(result) === result) {
                return result;
            }
            return this;
        } else {
            return target.apply(
                that,
                args.concat(slice.call(arguments))
            );
        }
    };

var boundLength = Math.max(0, target.length - args.length);
    var boundArgs = [];
    for (var i = 0; i < boundLength; i++) {
        boundArgs.push('$' + i);
    }

bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);

if (target.prototype) {
        var Empty = function Empty() {};
        Empty.prototype = target.prototype;
        bound.prototype = new Empty();
        Empty.prototype = null;
    }

return bound;
};

/***/ }),
/* 945 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {// @flow

var key = '__global_unique_id__';

module.exports = function() {
  return global[key] = (global[key] || 0) + 1;
};

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 946 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var origSymbol = typeof Symbol !== 'undefined' && Symbol;
var hasSymbolSham = __webpack_require__(414);

module.exports = function hasNativeSymbols() {
	if (typeof origSymbol !== 'function') { return false; }
	if (typeof Symbol !== 'function') { return false; }
	if (typeof origSymbol('foo') !== 'symbol') { return false; }
	if (typeof Symbol('bar') !== 'symbol') { return false; }

return hasSymbolSham();
};

/***/ }),
/* 947 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var bind = __webpack_require__(264);

module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);

/***/ }),
/* 948 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
var _slice = Array.prototype.slice;
exports.loopAsync = loopAsync;

function loopAsync(turns, work, callback) {
  var currentTurn = 0,
      isDone = false;
  var sync = false,
      hasNext = false,
      doneArgs = undefined;

function done() {
    isDone = true;
    if (sync) {
      // Iterate instead of recursing if possible.
      doneArgs = [].concat(_slice.call(arguments));
      return;
    }

callback.apply(this, arguments);
  }

function next() {
    if (isDone) {
      return;
    }

hasNext = true;
    if (sync) {
      // Iterate instead of recursing if possible.
      return;
    }

sync = true;

while (!isDone && currentTurn < turns && hasNext) {
      hasNext = false;
      work.call(this, currentTurn++, next, done);
    }

sync = false;

if (isDone) {
      // This means the loop finished synchronously.
      callback.apply(this, doneArgs);
      return;
    }

if (currentTurn >= turns && hasNext) {
      isDone = true;
      callback();
    }
  }

next();
}

/***/ }),
/* 949 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _Actions = __webpack_require__(105);

var _PathUtils = __webpack_require__(83);

var _ExecutionEnvironment = __webpack_require__(169);

var _DOMUtils = __webpack_require__(267);

var _DOMStateStorage = __webpack_require__(415);

var _createDOMHistory = __webpack_require__(416);

var _createDOMHistory2 = _interopRequireDefault(_createDOMHistory);

/**
 * Creates and returns a history object that uses HTML5's history API
 * (pushState, replaceState, and the popstate event) to manage history.
 * This is the recommended method of managing history in browsers because
 * it provides the cleanest URLs.
 *
 * Note: In browsers that do not support the HTML5 history API full
 * page reloads will be used to preserve URLs.
 */
function createBrowserHistory() {
  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

!_ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? _invariant2['default'](false, 'Browser history needs a DOM') : _invariant2['default'](false) : undefined;

var forceRefresh = options.forceRefresh;

var isSupported = _DOMUtils.supportsHistory();
  var useRefresh = !isSupported || forceRefresh;

function getCurrentLocation(historyState) {
    try {
      historyState = historyState || window.history.state || {};
    } catch (e) {
      historyState = {};
    }

var path = _DOMUtils.getWindowPath();
    var _historyState = historyState;
    var key = _historyState.key;

var state = undefined;
    if (key) {
      state = _DOMStateStorage.readState(key);
    } else {
      state = null;
      key = history.createKey();

if (isSupported) window.history.replaceState(_extends({}, historyState, { key: key }), null);
    }

var location = _PathUtils.parsePath(path);

return history.createLocation(_extends({}, location, { state: state }), undefined, key);
  }

function startPopStateListener(_ref) {
    var transitionTo = _ref.transitionTo;

function popStateListener(event) {
      if (event.state === undefined) return; // Ignore extraneous popstate events in WebKit.

transitionTo(getCurrentLocation(event.state));
    }

_DOMUtils.addEventListener(window, 'popstate', popStateListener);

return function () {
      _DOMUtils.removeEventListener(window, 'popstate', popStateListener);
    };
  }

function finishTransition(location) {
    var basename = location.basename;
    var pathname = location.pathname;
    var search = location.search;
    var hash = location.hash;
    var state = location.state;
    var action = location.action;
    var key = location.key;

if (action === _Actions.POP) return; // Nothing to do.

_DOMStateStorage.saveState(key, state);

var path = (basename || '') + pathname + search + hash;
    var historyState = {
      key: key
    };

if (action === _Actions.PUSH) {
      if (useRefresh) {
        window.location.href = path;
        return false; // Prevent location update.
      } else {
          window.history.pushState(historyState, null, path);
        }
    } else {
      // REPLACE
      if (useRefresh) {
        window.location.replace(path);
        return false; // Prevent location update.
      } else {
          window.history.replaceState(historyState, null, path);
        }
    }
  }

var listenerCount = 0,
      stopPopStateListener = undefined;

function listenBefore(listener) {
    if (++listenerCount === 1) stopPopStateListener = startPopStateListener(history);

var unlisten = history.listenBefore(listener);

return function () {
      unlisten();

if (--listenerCount === 0) stopPopStateListener();
    };
  }

function listen(listener) {
    if (++listenerCount === 1) stopPopStateListener = startPopStateListener(history);

var unlisten = history.listen(listener);

return function () {
      unlisten();

if (--listenerCount === 0) stopPopStateListener();
    };
  }

// deprecated
  function registerTransitionHook(hook) {
    if (++listenerCount === 1) stopPopStateListener = startPopStateListener(history);

history.registerTransitionHook(hook);
  }

// deprecated
  function unregisterTransitionHook(hook) {
    history.unregisterTransitionHook(hook);

if (--listenerCount === 0) stopPopStateListener();
  }

return _extends({}, history, {
    listenBefore: listenBefore,
    listen: listen,
    registerTransitionHook: registerTransitionHook,
    unregisterTransitionHook: unregisterTransitionHook
  });
}

exports['default'] = createBrowserHistory;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 950 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

var _Actions = __webpack_require__(105);

var _PathUtils = __webpack_require__(83);

function createLocation() {
  var location = arguments.length <= 0 || arguments[0] === undefined ? '/' : arguments[0];
  var action = arguments.length <= 1 || arguments[1] === undefined ? _Actions.POP : arguments[1];
  var key = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];

var _fourthArg = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3];

if (typeof location === 'string') location = _PathUtils.parsePath(location);

if (typeof action === 'object') {
    process.env.NODE_ENV !== 'production' ? _warning2['default'](false, 'The state (2nd) argument to createLocation is deprecated; use a ' + 'location descriptor instead') : undefined;

location = _extends({}, location, { state: action });

action = key || _Actions.POP;
    key = _fourthArg;
  }

var pathname = location.pathname || '/';
  var search = location.search || '';
  var hash = location.hash || '';
  var state = location.state || null;

return {
    pathname: pathname,
    search: search,
    hash: hash,
    state: state,
    action: action,
    key: key
  };
}

exports['default'] = createLocation;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 951 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _warning = __webpack_require__(56);

var _warning2 = _interopRequireDefault(_warning);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _PathUtils = __webpack_require__(83);

var _Actions = __webpack_require__(105);

var _createHistory = __webpack_require__(418);

var _createHistory2 = _interopRequireDefault(_createHistory);

function createMemoryHistory() {
  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

if (Array.isArray(options)) {
    options = { entries: options };
  } else if (typeof options === 'string') {
    options = { entries: [options] };
  }

var history = _createHistory2['default'](_extends({}, options, {
    getCurrentLocation: getCurrentLocation,
    finishTransition: finishTransition,
    saveState: saveState,
    go: go
  }));

var _options = options;
  var entries = _options.entries;
  var current = _options.current;

if (typeof entries === 'string') {
    entries = [entries];
  } else if (!Array.isArray(entries)) {
    entries = ['/'];
  }

entries = entries.map(function (entry) {
    var key = history.createKey();

if (typeof entry === 'string') return { pathname: entry, key: key };

if (typeof entry === 'object' && entry) return _extends({}, entry, { key: key });

true ? process.env.NODE_ENV !== 'production' ? _invariant2['default'](false, 'Unable to create history entry from %s', entry) : _invariant2['default'](false) : undefined;
  });

if (current == null) {
    current = entries.length - 1;
  } else {
    !(current >= 0 && current < entries.length) ? process.env.NODE_ENV !== 'production' ? _invariant2['default'](false, 'Current index must be >= 0 and < %s, was %s', entries.length, current) : _invariant2['default'](false) : undefined;
  }

var storage = createStateStorage(entries);

function saveState(key, state) {
    storage[key] = state;
  }

function readState(key) {
    return storage[key];
  }

function getCurrentLocation() {
    var entry = entries[current];
    var basename = entry.basename;
    var pathname = entry.pathname;
    var search = entry.search;

var path = (basename || '') + pathname + (search || '');

var key = undefined,
        state = undefined;
    if (entry.key) {
      key = entry.key;
      state = readState(key);
    } else {
      key = history.createKey();
      state = null;
      entry.key = key;
    }

var location = _PathUtils.parsePath(path);

return history.createLocation(_extends({}, location, { state: state }), undefined, key);
  }

function canGo(n) {
    var index = current + n;
    return index >= 0 && index < entries.length;
  }

function go(n) {
    if (n) {
      if (!canGo(n)) {
        process.env.NODE_ENV !== 'production' ? _warning2['default'](false, 'Cannot go(%s) there is not enough history', n) : undefined;
        return;
      }

current += n;

var currentLocation = getCurrentLocation();

// change action to POP
      history.transitionTo(_extends({}, currentLocation, { action: _Actions.POP }));
    }
  }

function finishTransition(location) {
    switch (location.action) {
      case _Actions.PUSH:
        current += 1;

// if we are not on the top of stack
        // remove rest and push new
        if (current < entries.length) entries.splice(current);

entries.push(location);
        saveState(location.key, location.state);
        break;
      case _Actions.REPLACE:
        entries[current] = location;
        saveState(location.key, location.state);
        break;
    }
  }

return history;
}

exports['default'] = createMemoryHistory;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 952 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var strictUriEncode = __webpack_require__(1451);

exports.extract = function (str) {
	return str.split('?')[1] || '';
};

exports.parse = function (str) {
	if (typeof str !== 'string') {
		return {};
	}

str = str.trim().replace(/^(\?|#|&)/, '');

if (!str) {
		return {};
	}

return str.split('&').reduce(function (ret, param) {
		var parts = param.replace(/\+/g, ' ').split('=');
		// Firefox (pre 40) decodes `%3D` to `=`
		// https://github.com/sindresorhus/query-string/pull/37
		var key = parts.shift();
		var val = parts.length > 0 ? parts.join('=') : undefined;

key = decodeURIComponent(key);

// missing `=` should be `null`:
		// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
		val = val === undefined ? null : decodeURIComponent(val);

if (!ret.hasOwnProperty(key)) {
			ret[key] = val;
		} else if (Array.isArray(ret[key])) {
			ret[key].push(val);
		} else {
			ret[key] = [ret[key], val];
		}

return ret;
	}, {});
};

exports.stringify = function (obj) {
	return obj ? Object.keys(obj).sort().map(function (key) {
		var val = obj[key];

if (val === undefined) {
			return '';
		}

if (val === null) {
			return key;
		}

if (Array.isArray(val)) {
			return val.slice().sort().map(function (val2) {
				return strictUriEncode(key) + '=' + strictUriEncode(val2);
			}).join('&');
		}

return strictUriEncode(key) + '=' + strictUriEncode(val);
	}).filter(function (x) {
		return x.length > 0;
	}).join('&') : '';
};

/***/ }),
/* 953 */
/***/ (function(module, exports) {

/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
  var e, m
  var eLen = (nBytes * 8) - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var nBits = -7
  var i = isLE ? (nBytes - 1) : 0
  var d = isLE ? -1 : 1
  var s = buffer[offset + i]

i += d

e = s & ((1 << (-nBits)) - 1)
  s >>= (-nBits)
  nBits += eLen
  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}

m = e & ((1 << (-nBits)) - 1)
  e >>= (-nBits)
  nBits += mLen
  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}

if (e === 0) {
    e = 1 - eBias
  } else if (e === eMax) {
    return m ? NaN : ((s ? -1 : 1) * Infinity)
  } else {
    m = m + Math.pow(2, mLen)
    e = e - eBias
  }
  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}

exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
  var e, m, c
  var eLen = (nBytes * 8) - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
  var i = isLE ? 0 : (nBytes - 1)
  var d = isLE ? 1 : -1
  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

value = Math.abs(value)

if (isNaN(value) || value === Infinity) {
    m = isNaN(value) ? 1 : 0
    e = eMax
  } else {
    e = Math.floor(Math.log(value) / Math.LN2)
    if (value * (c = Math.pow(2, -e)) < 1) {
      e--
      c *= 2
    }
    if (e + eBias >= 1) {
      value += rt / c
    } else {
      value += rt * Math.pow(2, 1 - eBias)
    }
    if (value * c >= 2) {
      e++
      c /= 2
    }

if (e + eBias >= eMax) {
      m = 0
      e = eMax
    } else if (e + eBias >= 1) {
      m = ((value * c) - 1) * Math.pow(2, mLen)
      e = e + eBias
    } else {
      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
      e = 0
    }
  }

for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

e = (e << mLen) | m
  eLen += mLen
  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

buffer[offset + i - d] |= s * 128
}

/***/ }),
/* 954 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 * imagesLoaded v4.1.4
 * JavaScript is all like "You images are done yet or what?"
 * MIT License
 */

( function( window, factory ) { 'use strict';
  // universal module definition

/*global define: false, module: false, require: false */

if ( true ) {
    // AMD
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
      __webpack_require__(263)
    ], __WEBPACK_AMD_DEFINE_RESULT__ = function( EvEmitter ) {
      return factory( window, EvEmitter );
    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if ( typeof module == 'object' && module.exports ) {
    // CommonJS
    module.exports = factory(
      window,
      require('ev-emitter')
    );
  } else {
    // browser global
    window.imagesLoaded = factory(
      window,
      window.EvEmitter
    );
  }

})( typeof window !== 'undefined' ? window : this,

// --------------------------  factory -------------------------- //

function factory( window, EvEmitter ) {

'use strict';

var $ = window.jQuery;
var console = window.console;

// -------------------------- helpers -------------------------- //

// extend objects
function extend( a, b ) {
  for ( var prop in b ) {
    a[ prop ] = b[ prop ];
  }
  return a;
}

var arraySlice = Array.prototype.slice;

// turn element or nodeList into an array
function makeArray( obj ) {
  if ( Array.isArray( obj ) ) {
    // use object if already an array
    return obj;
  }

var isArrayLike = typeof obj == 'object' && typeof obj.length == 'number';
  if ( isArrayLike ) {
    // convert nodeList to array
    return arraySlice.call( obj );
  }

// array of single index
  return [ obj ];
}

// -------------------------- imagesLoaded -------------------------- //

/**
 * @param {Array, Element, NodeList, String} elem
 * @param {Object or Function} options - if function, use as callback
 * @param {Function} onAlways - callback function
 */
function ImagesLoaded( elem, options, onAlways ) {
  // coerce ImagesLoaded() without new, to be new ImagesLoaded()
  if ( !( this instanceof ImagesLoaded ) ) {
    return new ImagesLoaded( elem, options, onAlways );
  }
  // use elem as selector string
  var queryElem = elem;
  if ( typeof elem == 'string' ) {
    queryElem = document.querySelectorAll( elem );
  }
  // bail if bad element
  if ( !queryElem ) {
    console.error( 'Bad element for imagesLoaded ' + ( queryElem || elem ) );
    return;
  }

this.elements = makeArray( queryElem );
  this.options = extend( {}, this.options );
  // shift arguments if no options set
  if ( typeof options == 'function' ) {
    onAlways = options;
  } else {
    extend( this.options, options );
  }

if ( onAlways ) {
    this.on( 'always', onAlways );
  }

this.getImages();

if ( $ ) {
    // add jQuery Deferred object
    this.jqDeferred = new $.Deferred();
  }

// HACK check async to allow time to bind listeners
  setTimeout( this.check.bind( this ) );
}

ImagesLoaded.prototype = Object.create( EvEmitter.prototype );

ImagesLoaded.prototype.options = {};

ImagesLoaded.prototype.getImages = function() {
  this.images = [];

// filter & find items if we have an item selector
  this.elements.forEach( this.addElementImages, this );
};

/**
 * @param {Node} element
 */
ImagesLoaded.prototype.addElementImages = function( elem ) {
  // filter siblings
  if ( elem.nodeName == 'IMG' ) {
    this.addImage( elem );
  }
  // get background image on element
  if ( this.options.background === true ) {
    this.addElementBackgroundImages( elem );
  }

// find children
  // no non-element nodes, #143
  var nodeType = elem.nodeType;
  if ( !nodeType || !elementNodeTypes[ nodeType ] ) {
    return;
  }
  var childImgs = elem.querySelectorAll('img');
  // concat childElems to filterFound array
  for ( var i=0; i < childImgs.length; i++ ) {
    var img = childImgs[i];
    this.addImage( img );
  }

// get child background images
  if ( typeof this.options.background == 'string' ) {
    var children = elem.querySelectorAll( this.options.background );
    for ( i=0; i < children.length; i++ ) {
      var child = children[i];
      this.addElementBackgroundImages( child );
    }
  }
};

var elementNodeTypes = {
  1: true,
  9: true,
  11: true
};

ImagesLoaded.prototype.addElementBackgroundImages = function( elem ) {
  var style = getComputedStyle( elem );
  if ( !style ) {
    // Firefox returns null if in a hidden iframe https://bugzil.la/548397
    return;
  }
  // get url inside url("...")
  var reURL = /url$(['"])?(.*?)\1$/gi;
  var matches = reURL.exec( style.backgroundImage );
  while ( matches !== null ) {
    var url = matches && matches[2];
    if ( url ) {
      this.addBackground( url, elem );
    }
    matches = reURL.exec( style.backgroundImage );
  }
};

/**
 * @param {Image} img
 */
ImagesLoaded.prototype.addImage = function( img ) {
  var loadingImage = new LoadingImage( img );
  this.images.push( loadingImage );
};

ImagesLoaded.prototype.addBackground = function( url, elem ) {
  var background = new Background( url, elem );
  this.images.push( background );
};

ImagesLoaded.prototype.check = function() {
  var _this = this;
  this.progressedCount = 0;
  this.hasAnyBroken = false;
  // complete if no images
  if ( !this.images.length ) {
    this.complete();
    return;
  }

function onProgress( image, elem, message ) {
    // HACK - Chrome triggers event before object properties have changed. #83
    setTimeout( function() {
      _this.progress( image, elem, message );
    });
  }

this.images.forEach( function( loadingImage ) {
    loadingImage.once( 'progress', onProgress );
    loadingImage.check();
  });
};

ImagesLoaded.prototype.progress = function( image, elem, message ) {
  this.progressedCount++;
  this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded;
  // progress event
  this.emitEvent( 'progress', [ this, image, elem ] );
  if ( this.jqDeferred && this.jqDeferred.notify ) {
    this.jqDeferred.notify( this, image );
  }
  // check if completed
  if ( this.progressedCount == this.images.length ) {
    this.complete();
  }

if ( this.options.debug && console ) {
    console.log( 'progress: ' + message, image, elem );
  }
};

ImagesLoaded.prototype.complete = function() {
  var eventName = this.hasAnyBroken ? 'fail' : 'done';
  this.isComplete = true;
  this.emitEvent( eventName, [ this ] );
  this.emitEvent( 'always', [ this ] );
  if ( this.jqDeferred ) {
    var jqMethod = this.hasAnyBroken ? 'reject' : 'resolve';
    this.jqDeferred[ jqMethod ]( this );
  }
};

// --------------------------  -------------------------- //

function LoadingImage( img ) {
  this.img = img;
}

LoadingImage.prototype = Object.create( EvEmitter.prototype );

LoadingImage.prototype.check = function() {
  // If complete is true and browser supports natural sizes,
  // try to check for image status manually.
  var isComplete = this.getIsImageComplete();
  if ( isComplete ) {
    // report based on naturalWidth
    this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' );
    return;
  }

// If none of the checks above matched, simulate loading on detached element.
  this.proxyImage = new Image();
  this.proxyImage.addEventListener( 'load', this );
  this.proxyImage.addEventListener( 'error', this );
  // bind to image as well for Firefox. #191
  this.img.addEventListener( 'load', this );
  this.img.addEventListener( 'error', this );
  this.proxyImage.src = this.img.src;
};

LoadingImage.prototype.getIsImageComplete = function() {
  // check for non-zero, non-undefined naturalWidth
  // fixes Safari+InfiniteScroll+Masonry bug infinite-scroll#671
  return this.img.complete && this.img.naturalWidth;
};

LoadingImage.prototype.confirm = function( isLoaded, message ) {
  this.isLoaded = isLoaded;
  this.emitEvent( 'progress', [ this, this.img, message ] );
};

// ----- events ----- //

// trigger specified handler for event type
LoadingImage.prototype.handleEvent = function( event ) {
  var method = 'on' + event.type;
  if ( this[ method ] ) {
    this[ method ]( event );
  }
};

LoadingImage.prototype.onload = function() {
  this.confirm( true, 'onload' );
  this.unbindEvents();
};

LoadingImage.prototype.onerror = function() {
  this.confirm( false, 'onerror' );
  this.unbindEvents();
};

LoadingImage.prototype.unbindEvents = function() {
  this.proxyImage.removeEventListener( 'load', this );
  this.proxyImage.removeEventListener( 'error', this );
  this.img.removeEventListener( 'load', this );
  this.img.removeEventListener( 'error', this );
};

// -------------------------- Background -------------------------- //

function Background( url, element ) {
  this.url = url;
  this.element = element;
  this.img = new Image();
}

// inherit LoadingImage prototype
Background.prototype = Object.create( LoadingImage.prototype );

Background.prototype.check = function() {
  this.img.addEventListener( 'load', this );
  this.img.addEventListener( 'error', this );
  this.img.src = this.url;
  // check if image is already complete
  var isComplete = this.getIsImageComplete();
  if ( isComplete ) {
    this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' );
    this.unbindEvents();
  }
};

Background.prototype.unbindEvents = function() {
  this.img.removeEventListener( 'load', this );
  this.img.removeEventListener( 'error', this );
};

Background.prototype.confirm = function( isLoaded, message ) {
  this.isLoaded = isLoaded;
  this.emitEvent( 'progress', [ this, this.element, message ] );
};

// -------------------------- jQuery -------------------------- //

ImagesLoaded.makeJQueryPlugin = function( jQuery ) {
  jQuery = jQuery || window.jQuery;
  if ( !jQuery ) {
    return;
  }
  // set local variable
  $ = jQuery;
  // $().imagesLoaded()
  $.fn.imagesLoaded = function( options, callback ) {
    var instance = new ImagesLoaded( this, options, callback );
    return instance.jqDeferred.promise( $(this) );
  };
};
// try making plugin
ImagesLoaded.makeJQueryPlugin();

// --------------------------  -------------------------- //

return ImagesLoaded;

});

/***/ }),
/* 955 */
/***/ (function(module, exports, __webpack_require__) {

/**
 *  Copyright (c) 2014-2015, Facebook, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  LICENSE file in the root directory of this source tree. An additional grant
 *  of patent rights can be found in the PATENTS file in the same directory.
 */

(function (global, factory) {
   true ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global.Immutable = factory());
}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;

function createClass(ctor, superClass) {
    if (superClass) {
      ctor.prototype = Object.create(superClass.prototype);
    }
    ctor.prototype.constructor = ctor;
  }

function Iterable(value) {
      return isIterable(value) ? value : Seq(value);
    }

createClass(KeyedIterable, Iterable);
    function KeyedIterable(value) {
      return isKeyed(value) ? value : KeyedSeq(value);
    }

createClass(IndexedIterable, Iterable);
    function IndexedIterable(value) {
      return isIndexed(value) ? value : IndexedSeq(value);
    }

createClass(SetIterable, Iterable);
    function SetIterable(value) {
      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);
    }

function isIterable(maybeIterable) {
    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);
  }

function isKeyed(maybeKeyed) {
    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);
  }

function isIndexed(maybeIndexed) {
    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);
  }

function isAssociative(maybeAssociative) {
    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
  }

function isOrdered(maybeOrdered) {
    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);
  }

Iterable.isIterable = isIterable;
  Iterable.isKeyed = isKeyed;
  Iterable.isIndexed = isIndexed;
  Iterable.isAssociative = isAssociative;
  Iterable.isOrdered = isOrdered;

Iterable.Keyed = KeyedIterable;
  Iterable.Indexed = IndexedIterable;
  Iterable.Set = SetIterable;

var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';

// Used for setting prototype methods that IE8 chokes on.
  var DELETE = 'delete';

// Constants describing the size of trie nodes.
  var SHIFT = 5; // Resulted in best performance after ______?
  var SIZE = 1 << SHIFT;
  var MASK = SIZE - 1;

// A consistent shared value representing "not set" which equals nothing other
  // than itself, and nothing that could be provided externally.
  var NOT_SET = {};

// Boolean references, Rough equivalent of `bool &`.
  var CHANGE_LENGTH = { value: false };
  var DID_ALTER = { value: false };

function MakeRef(ref) {
    ref.value = false;
    return ref;
  }

function SetRef(ref) {
    ref && (ref.value = true);
  }

// A function which returns a value representing an "owner" for transient writes
  // to tries. The return value will only ever equal itself, and will not equal
  // the return of any subsequent call of this function.
  function OwnerID() {}

// http://jsperf.com/copy-array-inline
  function arrCopy(arr, offset) {
    offset = offset || 0;
    var len = Math.max(0, arr.length - offset);
    var newArr = new Array(len);
    for (var ii = 0; ii < len; ii++) {
      newArr[ii] = arr[ii + offset];
    }
    return newArr;
  }

function ensureSize(iter) {
    if (iter.size === undefined) {
      iter.size = iter.__iterate(returnTrue);
    }
    return iter.size;
  }

function returnTrue() {
    return true;
  }

function wholeSlice(begin, end, size) {
    return (begin === 0 || (size !== undefined && begin <= -size)) &&
      (end === undefined || (size !== undefined && end >= size));
  }

function resolveBegin(begin, size) {
    return resolveIndex(begin, size, 0);
  }

function resolveEnd(end, size) {
    return resolveIndex(end, size, size);
  }

function resolveIndex(index, size, defaultIndex) {
    return index === undefined ?
      defaultIndex :
      index < 0 ?
        Math.max(0, size + index) :
        size === undefined ?
          index :
          Math.min(size, index);
  }

/* global Symbol */

var ITERATE_KEYS = 0;
  var ITERATE_VALUES = 1;
  var ITERATE_ENTRIES = 2;

var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
  var FAUX_ITERATOR_SYMBOL = '@@iterator';

var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;

function Iterator(next) {
      this.next = next;
    }

Iterator.prototype.toString = function() {
      return '[Iterator]';
    };

Iterator.KEYS = ITERATE_KEYS;
  Iterator.VALUES = ITERATE_VALUES;
  Iterator.ENTRIES = ITERATE_ENTRIES;

Iterator.prototype.inspect =
  Iterator.prototype.toSource = function () { return this.toString(); }
  Iterator.prototype[ITERATOR_SYMBOL] = function () {
    return this;
  };

function iteratorValue(type, k, v, iteratorResult) {
    var value = type === 0 ? k : type === 1 ? v : [k, v];
    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {
      value: value, done: false
    });
    return iteratorResult;
  }

function iteratorDone() {
    return { value: undefined, done: true };
  }

function hasIterator(maybeIterable) {
    return !!getIteratorFn(maybeIterable);
  }

function isIterator(maybeIterator) {
    return maybeIterator && typeof maybeIterator.next === 'function';
  }

function getIterator(iterable) {
    var iteratorFn = getIteratorFn(iterable);
    return iteratorFn && iteratorFn.call(iterable);
  }

function getIteratorFn(iterable) {
    var iteratorFn = iterable && (
      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
      iterable[FAUX_ITERATOR_SYMBOL]
    );
    if (typeof iteratorFn === 'function') {
      return iteratorFn;
    }
  }

function isArrayLike(value) {
    return value && typeof value.length === 'number';
  }

createClass(Seq, Iterable);
    function Seq(value) {
      return value === null || value === undefined ? emptySequence() :
        isIterable(value) ? value.toSeq() : seqFromValue(value);
    }

Seq.of = function(/*...values*/) {
      return Seq(arguments);
    };

Seq.prototype.toSeq = function() {
      return this;
    };

Seq.prototype.toString = function() {
      return this.__toString('Seq {', '}');
    };

Seq.prototype.cacheResult = function() {
      if (!this._cache && this.__iterateUncached) {
        this._cache = this.entrySeq().toArray();
        this.size = this._cache.length;
      }
      return this;
    };

// abstract __iterateUncached(fn, reverse)

Seq.prototype.__iterate = function(fn, reverse) {
      return seqIterate(this, fn, reverse, true);
    };

// abstract __iteratorUncached(type, reverse)

Seq.prototype.__iterator = function(type, reverse) {
      return seqIterator(this, type, reverse, true);
    };

createClass(KeyedSeq, Seq);
    function KeyedSeq(value) {
      return value === null || value === undefined ?
        emptySequence().toKeyedSeq() :
        isIterable(value) ?
          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :
          keyedSeqFromValue(value);
    }

KeyedSeq.prototype.toKeyedSeq = function() {
      return this;
    };

createClass(IndexedSeq, Seq);
    function IndexedSeq(value) {
      return value === null || value === undefined ? emptySequence() :
        !isIterable(value) ? indexedSeqFromValue(value) :
        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();
    }

IndexedSeq.of = function(/*...values*/) {
      return IndexedSeq(arguments);
    };

IndexedSeq.prototype.toIndexedSeq = function() {
      return this;
    };

IndexedSeq.prototype.toString = function() {
      return this.__toString('Seq [', ']');
    };

IndexedSeq.prototype.__iterate = function(fn, reverse) {
      return seqIterate(this, fn, reverse, false);
    };

IndexedSeq.prototype.__iterator = function(type, reverse) {
      return seqIterator(this, type, reverse, false);
    };

createClass(SetSeq, Seq);
    function SetSeq(value) {
      return (
        value === null || value === undefined ? emptySequence() :
        !isIterable(value) ? indexedSeqFromValue(value) :
        isKeyed(value) ? value.entrySeq() : value
      ).toSetSeq();
    }

SetSeq.of = function(/*...values*/) {
      return SetSeq(arguments);
    };

SetSeq.prototype.toSetSeq = function() {
      return this;
    };

Seq.isSeq = isSeq;
  Seq.Keyed = KeyedSeq;
  Seq.Set = SetSeq;
  Seq.Indexed = IndexedSeq;

var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';

Seq.prototype[IS_SEQ_SENTINEL] = true;

createClass(ArraySeq, IndexedSeq);
    function ArraySeq(array) {
      this._array = array;
      this.size = array.length;
    }

ArraySeq.prototype.get = function(index, notSetValue) {
      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;
    };

ArraySeq.prototype.__iterate = function(fn, reverse) {
      var array = this._array;
      var maxIndex = array.length - 1;
      for (var ii = 0; ii <= maxIndex; ii++) {
        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

ArraySeq.prototype.__iterator = function(type, reverse) {
      var array = this._array;
      var maxIndex = array.length - 1;
      var ii = 0;
      return new Iterator(function() 
        {return ii > maxIndex ?
          iteratorDone() :
          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}
      );
    };

createClass(ObjectSeq, KeyedSeq);
    function ObjectSeq(object) {
      var keys = Object.keys(object);
      this._object = object;
      this._keys = keys;
      this.size = keys.length;
    }

ObjectSeq.prototype.get = function(key, notSetValue) {
      if (notSetValue !== undefined && !this.has(key)) {
        return notSetValue;
      }
      return this._object[key];
    };

ObjectSeq.prototype.has = function(key) {
      return this._object.hasOwnProperty(key);
    };

ObjectSeq.prototype.__iterate = function(fn, reverse) {
      var object = this._object;
      var keys = this._keys;
      var maxIndex = keys.length - 1;
      for (var ii = 0; ii <= maxIndex; ii++) {
        var key = keys[reverse ? maxIndex - ii : ii];
        if (fn(object[key], key, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

ObjectSeq.prototype.__iterator = function(type, reverse) {
      var object = this._object;
      var keys = this._keys;
      var maxIndex = keys.length - 1;
      var ii = 0;
      return new Iterator(function()  {
        var key = keys[reverse ? maxIndex - ii : ii];
        return ii++ > maxIndex ?
          iteratorDone() :
          iteratorValue(type, key, object[key]);
      });
    };

ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;

createClass(IterableSeq, IndexedSeq);
    function IterableSeq(iterable) {
      this._iterable = iterable;
      this.size = iterable.length || iterable.size;
    }

IterableSeq.prototype.__iterateUncached = function(fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterable = this._iterable;
      var iterator = getIterator(iterable);
      var iterations = 0;
      if (isIterator(iterator)) {
        var step;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
      }
      return iterations;
    };

IterableSeq.prototype.__iteratorUncached = function(type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterable = this._iterable;
      var iterator = getIterator(iterable);
      if (!isIterator(iterator)) {
        return new Iterator(iteratorDone);
      }
      var iterations = 0;
      return new Iterator(function()  {
        var step = iterator.next();
        return step.done ? step : iteratorValue(type, iterations++, step.value);
      });
    };

createClass(IteratorSeq, IndexedSeq);
    function IteratorSeq(iterator) {
      this._iterator = iterator;
      this._iteratorCache = [];
    }

IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterator = this._iterator;
      var cache = this._iteratorCache;
      var iterations = 0;
      while (iterations < cache.length) {
        if (fn(cache[iterations], iterations++, this) === false) {
          return iterations;
        }
      }
      var step;
      while (!(step = iterator.next()).done) {
        var val = step.value;
        cache[iterations] = val;
        if (fn(val, iterations++, this) === false) {
          break;
        }
      }
      return iterations;
    };

IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterator = this._iterator;
      var cache = this._iteratorCache;
      var iterations = 0;
      return new Iterator(function()  {
        if (iterations >= cache.length) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          cache[iterations] = step.value;
        }
        return iteratorValue(type, iterations, cache[iterations++]);
      });
    };

// # pragma Helper functions

function isSeq(maybeSeq) {
    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);
  }

var EMPTY_SEQ;

function emptySequence() {
    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
  }

function keyedSeqFromValue(value) {
    var seq =
      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :
      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :
      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :
      typeof value === 'object' ? new ObjectSeq(value) :
      undefined;
    if (!seq) {
      throw new TypeError(
        'Expected Array or iterable object of [k, v] entries, '+
        'or keyed object: ' + value
      );
    }
    return seq;
  }

function indexedSeqFromValue(value) {
    var seq = maybeIndexedSeqFromValue(value);
    if (!seq) {
      throw new TypeError(
        'Expected Array or iterable object of values: ' + value
      );
    }
    return seq;
  }

function seqFromValue(value) {
    var seq = maybeIndexedSeqFromValue(value) ||
      (typeof value === 'object' && new ObjectSeq(value));
    if (!seq) {
      throw new TypeError(
        'Expected Array or iterable object of values, or keyed object: ' + value
      );
    }
    return seq;
  }

function maybeIndexedSeqFromValue(value) {
    return (
      isArrayLike(value) ? new ArraySeq(value) :
      isIterator(value) ? new IteratorSeq(value) :
      hasIterator(value) ? new IterableSeq(value) :
      undefined
    );
  }

function fromJS(json, converter) {
    return converter ?
      fromJSWith(converter, json, '', {'': json}) :
      fromJSDefault(json);
  }

function isPlainObj(value) {
    return value && (value.constructor === Object || value.constructor === undefined);
  }

/**
   * An extension of the "same-value" algorithm as [described for use by ES6 Map
   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
   *
   * NaN is considered the same as NaN, however -0 and 0 are considered the same
   * value, which is different from the algorithm described by
   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
   *
   * This is extended further to allow Objects to describe the values they
   * represent, by way of `valueOf` or `equals` (and `hashCode`).
   *
   * Note: because of this extension, the key equality of Immutable.Map and the
   * value equality of Immutable.Set will differ from ES6 Map and Set.
   *
   * ### Defining custom values
   *
   * The easiest way to describe the value an object represents is by implementing
   * `valueOf`. For example, `Date` represents a value by returning a unix
   * timestamp for `valueOf`:
   *
   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
   *     var date2 = new Date(1234567890000);
   *     date1.valueOf(); // 1234567890000
   *     assert( date1 !== date2 );
   *     assert( Immutable.is( date1, date2 ) );
   *
   * Note: overriding `valueOf` may have other implications if you use this object
   * where JavaScript expects a primitive, such as implicit string coercion.
   *
   * For more complex types, especially collections, implementing `valueOf` may
   * not be performant. An alternative is to implement `equals` and `hashCode`.
   *
   * `equals` takes another object, presumably of similar type, and returns true
   * if the it is equal. Equality is symmetrical, so the same result should be
   * returned if this and the argument are flipped.
   *
   *     assert( a.equals(b) === b.equals(a) );
   *
   * `hashCode` returns a 32bit integer number representing the object which will
   * be used to determine how to store the value object in a Map or Set. You must
   * provide both or neither methods, one must not exist without the other.
   *
   * Also, an important relationship between these methods must be upheld: if two
   * values are equal, they *must* return the same hashCode. If the values are not
   * equal, they might have the same hashCode; this is called a hash collision,
   * and while undesirable for performance reasons, it is acceptable.
   *
   *     if (a.equals(b)) {
   *       assert( a.hashCode() === b.hashCode() );
   *     }
   *
   * All Immutable collections implement `equals` and `hashCode`.
   *
   */
  function is(valueA, valueB) {
    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
      return true;
    }
    if (!valueA || !valueB) {
      return false;
    }
    if (typeof valueA.valueOf === 'function' &&
        typeof valueB.valueOf === 'function') {
      valueA = valueA.valueOf();
      valueB = valueB.valueOf();
      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
        return true;
      }
      if (!valueA || !valueB) {
        return false;
      }
    }
    if (typeof valueA.equals === 'function' &&
        typeof valueB.equals === 'function' &&
        valueA.equals(valueB)) {
      return true;
    }
    return false;
  }

function deepEqual(a, b) {
    if (a === b) {
      return true;
    }

if (
      !isIterable(b) ||
      a.size !== undefined && b.size !== undefined && a.size !== b.size ||
      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||
      isKeyed(a) !== isKeyed(b) ||
      isIndexed(a) !== isIndexed(b) ||
      isOrdered(a) !== isOrdered(b)
    ) {
      return false;
    }

if (a.size === 0 && b.size === 0) {
      return true;
    }

var notAssociative = !isAssociative(a);

if (isOrdered(a)) {
      var entries = a.entries();
      return b.every(function(v, k)  {
        var entry = entries.next().value;
        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));
      }) && entries.next().done;
    }

var flipped = false;

if (a.size === undefined) {
      if (b.size === undefined) {
        if (typeof a.cacheResult === 'function') {
          a.cacheResult();
        }
      } else {
        flipped = true;
        var _ = a;
        a = b;
        b = _;
      }
    }

var allEqual = true;
    var bSize = b.__iterate(function(v, k)  {
      if (notAssociative ? !a.has(v) :
          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {
        allEqual = false;
        return false;
      }
    });

return allEqual && a.size === bSize;
  }

createClass(Repeat, IndexedSeq);

Repeat.prototype.toString = function() {
      if (this.size === 0) {
        return 'Repeat []';
      }
      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';
    };

Repeat.prototype.get = function(index, notSetValue) {
      return this.has(index) ? this._value : notSetValue;
    };

Repeat.prototype.includes = function(searchValue) {
      return is(this._value, searchValue);
    };

Repeat.prototype.slice = function(begin, end) {
      var size = this.size;
      return wholeSlice(begin, end, size) ? this :
        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));
    };

Repeat.prototype.reverse = function() {
      return this;
    };

Repeat.prototype.indexOf = function(searchValue) {
      if (is(this._value, searchValue)) {
        return 0;
      }
      return -1;
    };

Repeat.prototype.lastIndexOf = function(searchValue) {
      if (is(this._value, searchValue)) {
        return this.size;
      }
      return -1;
    };

Repeat.prototype.__iterate = function(fn, reverse) {
      for (var ii = 0; ii < this.size; ii++) {
        if (fn(this._value, ii, this) === false) {
          return ii + 1;
        }
      }
      return ii;
    };

Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;
      var ii = 0;
      return new Iterator(function() 
        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}
      );
    };

Repeat.prototype.equals = function(other) {
      return other instanceof Repeat ?
        is(this._value, other._value) :
        deepEqual(other);
    };

var EMPTY_REPEAT;

function invariant(condition, error) {
    if (!condition) throw new Error(error);
  }

createClass(Range, IndexedSeq);

Range.prototype.toString = function() {
      if (this.size === 0) {
        return 'Range []';
      }
      return 'Range [ ' +
        this._start + '...' + this._end +
        (this._step !== 1 ? ' by ' + this._step : '') +
      ' ]';
    };

Range.prototype.get = function(index, notSetValue) {
      return this.has(index) ?
        this._start + wrapIndex(this, index) * this._step :
        notSetValue;
    };

Range.prototype.includes = function(searchValue) {
      var possibleIndex = (searchValue - this._start) / this._step;
      return possibleIndex >= 0 &&
        possibleIndex < this.size &&
        possibleIndex === Math.floor(possibleIndex);
    };

Range.prototype.slice = function(begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      begin = resolveBegin(begin, this.size);
      end = resolveEnd(end, this.size);
      if (end <= begin) {
        return new Range(0, 0);
      }
      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);
    };

Range.prototype.indexOf = function(searchValue) {
      var offsetValue = searchValue - this._start;
      if (offsetValue % this._step === 0) {
        var index = offsetValue / this._step;
        if (index >= 0 && index < this.size) {
          return index
        }
      }
      return -1;
    };

Range.prototype.lastIndexOf = function(searchValue) {
      return this.indexOf(searchValue);
    };

Range.prototype.__iterate = function(fn, reverse) {
      var maxIndex = this.size - 1;
      var step = this._step;
      var value = reverse ? this._start + maxIndex * step : this._start;
      for (var ii = 0; ii <= maxIndex; ii++) {
        if (fn(value, ii, this) === false) {
          return ii + 1;
        }
        value += reverse ? -step : step;
      }
      return ii;
    };

Range.prototype.__iterator = function(type, reverse) {
      var maxIndex = this.size - 1;
      var step = this._step;
      var value = reverse ? this._start + maxIndex * step : this._start;
      var ii = 0;
      return new Iterator(function()  {
        var v = value;
        value += reverse ? -step : step;
        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);
      });
    };

Range.prototype.equals = function(other) {
      return other instanceof Range ?
        this._start === other._start &&
        this._end === other._end &&
        this._step === other._step :
        deepEqual(this, other);
    };

var EMPTY_RANGE;

createClass(Collection, Iterable);
    function Collection() {
      throw TypeError('Abstract');
    }

createClass(KeyedCollection, Collection);function KeyedCollection() {}

createClass(IndexedCollection, Collection);function IndexedCollection() {}

createClass(SetCollection, Collection);function SetCollection() {}

Collection.Keyed = KeyedCollection;
  Collection.Indexed = IndexedCollection;
  Collection.Set = SetCollection;

var imul =
    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?
    Math.imul :
    function imul(a, b) {
      a = a | 0; // int
      b = b | 0; // int
      var c = a & 0xffff;
      var d = b & 0xffff;
      // Shift by 0 fixes the sign on the high part.
      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int
    };

// v8 has an optimization for storing 31-bit signed numbers.
  // Values which have either 00 or 11 as the high order bits qualify.
  // This function drops the highest order bit in a signed number, maintaining
  // the sign bit.
  function smi(i32) {
    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);
  }

// http://jsperf.com/hashing-strings
  function hashString(string) {
    // This is the hash from JVM
    // The hash code for a string is computed as
    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
    // where s[i] is the ith character of the string and n is the length of
    // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
    // (exclusive) by dropping high bits.
    var hash = 0;
    for (var ii = 0; ii < string.length; ii++) {
      hash = 31 * hash + string.charCodeAt(ii) | 0;
    }
    return smi(hash);
  }

function hashJSObj(obj) {
    var hash;
    if (usingWeakMap) {
      hash = weakMap.get(obj);
      if (hash !== undefined) {
        return hash;
      }
    }

hash = obj[UID_HASH_KEY];
    if (hash !== undefined) {
      return hash;
    }

if (!canDefineProperty) {
      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
      if (hash !== undefined) {
        return hash;
      }

hash = getIENodeHash(obj);
      if (hash !== undefined) {
        return hash;
      }
    }

hash = ++objHashUID;
    if (objHashUID & 0x40000000) {
      objHashUID = 0;
    }

if (usingWeakMap) {
      weakMap.set(obj, hash);
    } else if (isExtensible !== undefined && isExtensible(obj) === false) {
      throw new Error('Non-extensible objects are not allowed as keys.');
    } else if (canDefineProperty) {
      Object.defineProperty(obj, UID_HASH_KEY, {
        'enumerable': false,
        'configurable': false,
        'writable': false,
        'value': hash
      });
    } else if (obj.propertyIsEnumerable !== undefined &&
               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {
      // Since we can't define a non-enumerable property on the object
      // we'll hijack one of the less-used non-enumerable properties to
      // save our hash on it. Since this is a function it will not show up in
      // `JSON.stringify` which is what we want.
      obj.propertyIsEnumerable = function() {
        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);
      };
      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;
    } else if (obj.nodeType !== undefined) {
      // At this point we couldn't get the IE `uniqueID` to use as a hash
      // and we couldn't use a non-enumerable property to exploit the
      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
      // itself.
      obj[UID_HASH_KEY] = hash;
    } else {
      throw new Error('Unable to set a non-enumerable property on object.');
    }

return hash;
  }

// Get references to ES5 object methods.
  var isExtensible = Object.isExtensible;

// True if Object.defineProperty works as expected. IE8 fails this test.
  var canDefineProperty = (function() {
    try {
      Object.defineProperty({}, '@', {});
      return true;
    } catch (e) {
      return false;
    }
  }());

// IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
  // and avoid memory leaks from the IE cloneNode bug.
  function getIENodeHash(node) {
    if (node && node.nodeType > 0) {
      switch (node.nodeType) {
        case 1: // Element
          return node.uniqueID;
        case 9: // Document
          return node.documentElement && node.documentElement.uniqueID;
      }
    }
  }

// If possible, use a WeakMap.
  var usingWeakMap = typeof WeakMap === 'function';
  var weakMap;
  if (usingWeakMap) {
    weakMap = new WeakMap();
  }

var objHashUID = 0;

var UID_HASH_KEY = '__immutablehash__';
  if (typeof Symbol === 'function') {
    UID_HASH_KEY = Symbol(UID_HASH_KEY);
  }

var STRING_HASH_CACHE_MIN_STRLEN = 16;
  var STRING_HASH_CACHE_MAX_SIZE = 255;
  var STRING_HASH_CACHE_SIZE = 0;
  var stringHashCache = {};

function assertNotInfinite(size) {
    invariant(
      size !== Infinity,
      'Cannot perform this action with an infinite size.'
    );
  }

createClass(Map, KeyedCollection);

// @pragma Construction

Map.of = function() {var keyValues = SLICE$0.call(arguments, 0);
      return emptyMap().withMutations(function(map ) {
        for (var i = 0; i < keyValues.length; i += 2) {
          if (i + 1 >= keyValues.length) {
            throw new Error('Missing value for key: ' + keyValues[i]);
          }
          map.set(keyValues[i], keyValues[i + 1]);
        }
      });
    };

Map.prototype.toString = function() {
      return this.__toString('Map {', '}');
    };

// @pragma Access

Map.prototype.get = function(k, notSetValue) {
      return this._root ?
        this._root.get(0, undefined, k, notSetValue) :
        notSetValue;
    };

// @pragma Modification

Map.prototype.set = function(k, v) {
      return updateMap(this, k, v);
    };

Map.prototype.setIn = function(keyPath, v) {
      return this.updateIn(keyPath, NOT_SET, function()  {return v});
    };

Map.prototype.remove = function(k) {
      return updateMap(this, k, NOT_SET);
    };

Map.prototype.deleteIn = function(keyPath) {
      return this.updateIn(keyPath, function()  {return NOT_SET});
    };

Map.prototype.update = function(k, notSetValue, updater) {
      return arguments.length === 1 ?
        k(this) :
        this.updateIn([k], notSetValue, updater);
    };

Map.prototype.updateIn = function(keyPath, notSetValue, updater) {
      if (!updater) {
        updater = notSetValue;
        notSetValue = undefined;
      }
      var updatedValue = updateInDeepMap(
        this,
        forceIterator(keyPath),
        notSetValue,
        updater
      );
      return updatedValue === NOT_SET ? undefined : updatedValue;
    };

Map.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._root = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyMap();
    };

// @pragma Composition

Map.prototype.merge = function(/*...iters*/) {
      return mergeIntoMapWith(this, undefined, arguments);
    };

Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, merger, iters);
    };

Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(
        keyPath,
        emptyMap(),
        function(m ) {return typeof m.merge === 'function' ?
          m.merge.apply(m, iters) :
          iters[iters.length - 1]}
      );
    };

Map.prototype.mergeDeep = function(/*...iters*/) {
      return mergeIntoMapWith(this, deepMerger, arguments);
    };

Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return mergeIntoMapWith(this, deepMergerWith(merger), iters);
    };

Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);
      return this.updateIn(
        keyPath,
        emptyMap(),
        function(m ) {return typeof m.mergeDeep === 'function' ?
          m.mergeDeep.apply(m, iters) :
          iters[iters.length - 1]}
      );
    };

Map.prototype.sort = function(comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator));
    };

Map.prototype.sortBy = function(mapper, comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator, mapper));
    };

// @pragma Mutability

Map.prototype.withMutations = function(fn) {
      var mutable = this.asMutable();
      fn(mutable);
      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
    };

Map.prototype.asMutable = function() {
      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
    };

Map.prototype.asImmutable = function() {
      return this.__ensureOwner();
    };

Map.prototype.wasAltered = function() {
      return this.__altered;
    };

Map.prototype.__iterator = function(type, reverse) {
      return new MapIterator(this, type, reverse);
    };

Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      var iterations = 0;
      this._root && this._root.iterate(function(entry ) {
        iterations++;
        return fn(entry[1], entry[0], this$0);
      }, reverse);
      return iterations;
    };

Map.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeMap(this.size, this._root, ownerID, this.__hash);
    };

function isMap(maybeMap) {
    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);
  }

Map.isMap = isMap;

var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';

var MapPrototype = Map.prototype;
  MapPrototype[IS_MAP_SENTINEL] = true;
  MapPrototype[DELETE] = MapPrototype.remove;
  MapPrototype.removeIn = MapPrototype.deleteIn;

// #pragma Trie Nodes

function ArrayMapNode(ownerID, entries) {
      this.ownerID = ownerID;
      this.entries = entries;
    }

ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      var removed = value === NOT_SET;

var entries = this.entries;
      var idx = 0;
      for (var len = entries.length; idx < len; idx++) {
        if (is(key, entries[idx][0])) {
          break;
        }
      }
      var exists = idx < len;

if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

if (removed && entries.length === 1) {
        return; // undefined
      }

if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
        return createNodes(ownerID, entries, key, value);
      }

var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

if (exists) {
        if (removed) {
          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());
        } else {
          newEntries[idx] = [key, value];
        }
      } else {
        newEntries.push([key, value]);
      }

if (isEditable) {
        this.entries = newEntries;
        return this;
      }

return new ArrayMapNode(ownerID, newEntries);
    };

function BitmapIndexedNode(ownerID, bitmap, nodes) {
      this.ownerID = ownerID;
      this.bitmap = bitmap;
      this.nodes = nodes;
    }

BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));
      var bitmap = this.bitmap;
      return (bitmap & bit) === 0 ? notSetValue :
        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);
    };

BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var bit = 1 << keyHashFrag;
      var bitmap = this.bitmap;
      var exists = (bitmap & bit) !== 0;

if (!exists && value === NOT_SET) {
        return this;
      }

var idx = popCount(bitmap & (bit - 1));
      var nodes = this.nodes;
      var node = exists ? nodes[idx] : undefined;
      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);

if (newNode === node) {
        return this;
      }

if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
      }

if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {
        return nodes[idx ^ 1];
      }

if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
        return newNode;
      }

var isEditable = ownerID && ownerID === this.ownerID;
      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;
      var newNodes = exists ? newNode ?
        setIn(nodes, idx, newNode, isEditable) :
        spliceOut(nodes, idx, isEditable) :
        spliceIn(nodes, idx, newNode, isEditable);

if (isEditable) {
        this.bitmap = newBitmap;
        this.nodes = newNodes;
        return this;
      }

return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
    };

function HashArrayMapNode(ownerID, count, nodes) {
      this.ownerID = ownerID;
      this.count = count;
      this.nodes = nodes;
    }

HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var node = this.nodes[idx];
      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;
    };

HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }
      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
      var removed = value === NOT_SET;
      var nodes = this.nodes;
      var node = nodes[idx];

if (removed && !node) {
        return this;
      }

var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);
      if (newNode === node) {
        return this;
      }

var isEditable = ownerID && ownerID === this.ownerID;
      var newNodes = setIn(nodes, idx, newNode, isEditable);

if (isEditable) {
        this.count = newCount;
        this.nodes = newNodes;
        return this;
      }

return new HashArrayMapNode(ownerID, newCount, newNodes);
    };

function HashCollisionNode(ownerID, keyHash, entries) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entries = entries;
    }

HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      var entries = this.entries;
      for (var ii = 0, len = entries.length; ii < len; ii++) {
        if (is(key, entries[ii][0])) {
          return entries[ii][1];
        }
      }
      return notSetValue;
    };

HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      if (keyHash === undefined) {
        keyHash = hash(key);
      }

var removed = value === NOT_SET;

if (keyHash !== this.keyHash) {
        if (removed) {
          return this;
        }
        SetRef(didAlter);
        SetRef(didChangeSize);
        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
      }

if (exists ? entries[idx][1] === value : removed) {
        return this;
      }

SetRef(didAlter);
      (removed || !exists) && SetRef(didChangeSize);

if (removed && len === 2) {
        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
      }

var isEditable = ownerID && ownerID === this.ownerID;
      var newEntries = isEditable ? entries : arrCopy(entries);

if (isEditable) {
        this.entries = newEntries;
        return this;
      }

return new HashCollisionNode(ownerID, this.keyHash, newEntries);
    };

function ValueNode(ownerID, keyHash, entry) {
      this.ownerID = ownerID;
      this.keyHash = keyHash;
      this.entry = entry;
    }

ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {
      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
    };

ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
      var removed = value === NOT_SET;
      var keyMatch = is(key, this.entry[0]);
      if (keyMatch ? value === this.entry[1] : removed) {
        return this;
      }

SetRef(didAlter);

if (removed) {
        SetRef(didChangeSize);
        return; // undefined
      }

if (keyMatch) {
        if (ownerID && ownerID === this.ownerID) {
          this.entry[1] = value;
          return this;
        }
        return new ValueNode(ownerID, this.keyHash, [key, value]);
      }

SetRef(didChangeSize);
      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
    };

// #pragma Iterators

ArrayMapNode.prototype.iterate =
  HashCollisionNode.prototype.iterate = function (fn, reverse) {
    var entries = this.entries;
    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
        return false;
      }
    }
  }

BitmapIndexedNode.prototype.iterate =
  HashArrayMapNode.prototype.iterate = function (fn, reverse) {
    var nodes = this.nodes;
    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
      var node = nodes[reverse ? maxIndex - ii : ii];
      if (node && node.iterate(fn, reverse) === false) {
        return false;
      }
    }
  }

ValueNode.prototype.iterate = function (fn, reverse) {
    return fn(this.entry);
  }

createClass(MapIterator, Iterator);

function MapIterator(map, type, reverse) {
      this._type = type;
      this._reverse = reverse;
      this._stack = map._root && mapIteratorFrame(map._root);
    }

MapIterator.prototype.next = function() {
      var type = this._type;
      var stack = this._stack;
      while (stack) {
        var node = stack.node;
        var index = stack.index++;
        var maxIndex;
        if (node.entry) {
          if (index === 0) {
            return mapIteratorValue(type, node.entry);
          }
        } else if (node.entries) {
          maxIndex = node.entries.length - 1;
          if (index <= maxIndex) {
            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);
          }
        } else {
          maxIndex = node.nodes.length - 1;
          if (index <= maxIndex) {
            var subNode = node.nodes[this._reverse ? maxIndex - index : index];
            if (subNode) {
              if (subNode.entry) {
                return mapIteratorValue(type, subNode.entry);
              }
              stack = this._stack = mapIteratorFrame(subNode, stack);
            }
            continue;
          }
        }
        stack = this._stack = this._stack.__prev;
      }
      return iteratorDone();
    };

function mapIteratorValue(type, entry) {
    return iteratorValue(type, entry[0], entry[1]);
  }

function mapIteratorFrame(node, prev) {
    return {
      node: node,
      index: 0,
      __prev: prev
    };
  }

function makeMap(size, root, ownerID, hash) {
    var map = Object.create(MapPrototype);
    map.size = size;
    map._root = root;
    map.__ownerID = ownerID;
    map.__hash = hash;
    map.__altered = false;
    return map;
  }

var EMPTY_MAP;
  function emptyMap() {
    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
  }

function isLeafNode(node) {
    return node.constructor === ValueNode || node.constructor === HashCollisionNode;
  }

function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
    if (node.keyHash === keyHash) {
      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
    }

var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;

var newNode;
    var nodes = idx1 === idx2 ?
      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :
      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);

return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
  }

function expandNodes(ownerID, nodes, bitmap, including, node) {
    var count = 0;
    var expandedNodes = new Array(SIZE);
    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
    }
    expandedNodes[including] = node;
    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
  }

function deepMerger(existing, value, key) {
    return existing && existing.mergeDeep && isIterable(value) ?
      existing.mergeDeep(value) :
      is(existing, value) ? existing : value;
  }

function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {
    var isNotSet = existing === NOT_SET;
    var step = keyPathIter.next();
    if (step.done) {
      var existingValue = isNotSet ? notSetValue : existing;
      var newValue = updater(existingValue);
      return newValue === existingValue ? existing : newValue;
    }
    invariant(
      isNotSet || (existing && existing.set),
      'invalid keyPath'
    );
    var key = step.value;
    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);
    var nextUpdated = updateInDeepMap(
      nextExisting,
      keyPathIter,
      notSetValue,
      updater
    );
    return nextUpdated === nextExisting ? existing :
      nextUpdated === NOT_SET ? existing.remove(key) :
      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);
  }

function popCount(x) {
    x = x - ((x >> 1) & 0x55555555);
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    x = (x + (x >> 4)) & 0x0f0f0f0f;
    x = x + (x >> 8);
    x = x + (x >> 16);
    return x & 0x7f;
  }

function setIn(array, idx, val, canEdit) {
    var newArray = canEdit ? array : arrCopy(array);
    newArray[idx] = val;
    return newArray;
  }

var MAX_ARRAY_MAP_SIZE = SIZE / 4;
  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;

createClass(List, IndexedCollection);

// @pragma Construction

List.of = function(/*...values*/) {
      return this(arguments);
    };

List.prototype.toString = function() {
      return this.__toString('List [', ']');
    };

// @pragma Access

List.prototype.get = function(index, notSetValue) {
      index = wrapIndex(this, index);
      if (index >= 0 && index < this.size) {
        index += this._origin;
        var node = listNodeFor(this, index);
        return node && node.array[index & MASK];
      }
      return notSetValue;
    };

// @pragma Modification

List.prototype.set = function(index, value) {
      return updateList(this, index, value);
    };

List.prototype.remove = function(index) {
      return !this.has(index) ? this :
        index === 0 ? this.shift() :
        index === this.size - 1 ? this.pop() :
        this.splice(index, 1);
    };

List.prototype.insert = function(index, value) {
      return this.splice(index, 0, value);
    };

List.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = this._origin = this._capacity = 0;
        this._level = SHIFT;
        this._root = this._tail = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyList();
    };

List.prototype.push = function(/*...values*/) {
      var values = arguments;
      var oldSize = this.size;
      return this.withMutations(function(list ) {
        setListBounds(list, 0, oldSize + values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(oldSize + ii, values[ii]);
        }
      });
    };

List.prototype.pop = function() {
      return setListBounds(this, 0, -1);
    };

List.prototype.unshift = function(/*...values*/) {
      var values = arguments;
      return this.withMutations(function(list ) {
        setListBounds(list, -values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(ii, values[ii]);
        }
      });
    };

List.prototype.shift = function() {
      return setListBounds(this, 1);
    };

// @pragma Composition

List.prototype.merge = function(/*...iters*/) {
      return mergeIntoListWith(this, undefined, arguments);
    };

List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, merger, iters);
    };

List.prototype.mergeDeep = function(/*...iters*/) {
      return mergeIntoListWith(this, deepMerger, arguments);
    };

List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return mergeIntoListWith(this, deepMergerWith(merger), iters);
    };

List.prototype.setSize = function(size) {
      return setListBounds(this, 0, size);
    };

// @pragma Iteration

List.prototype.slice = function(begin, end) {
      var size = this.size;
      if (wholeSlice(begin, end, size)) {
        return this;
      }
      return setListBounds(
        this,
        resolveBegin(begin, size),
        resolveEnd(end, size)
      );
    };

List.prototype.__iterator = function(type, reverse) {
      var index = 0;
      var values = iterateList(this, reverse);
      return new Iterator(function()  {
        var value = values();
        return value === DONE ?
          iteratorDone() :
          iteratorValue(type, index++, value);
      });
    };

List.prototype.__iterate = function(fn, reverse) {
      var index = 0;
      var values = iterateList(this, reverse);
      var value;
      while ((value = values()) !== DONE) {
        if (fn(value, index++, this) === false) {
          break;
        }
      }
      return index;
    };

List.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        return this;
      }
      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);
    };

function isList(maybeList) {
    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);
  }

List.isList = isList;

var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';

var ListPrototype = List.prototype;
  ListPrototype[IS_LIST_SENTINEL] = true;
  ListPrototype[DELETE] = ListPrototype.remove;
  ListPrototype.setIn = MapPrototype.setIn;
  ListPrototype.deleteIn =
  ListPrototype.removeIn = MapPrototype.removeIn;
  ListPrototype.update = MapPrototype.update;
  ListPrototype.updateIn = MapPrototype.updateIn;
  ListPrototype.mergeIn = MapPrototype.mergeIn;
  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
  ListPrototype.withMutations = MapPrototype.withMutations;
  ListPrototype.asMutable = MapPrototype.asMutable;
  ListPrototype.asImmutable = MapPrototype.asImmutable;
  ListPrototype.wasAltered = MapPrototype.wasAltered;

function VNode(array, ownerID) {
      this.array = array;
      this.ownerID = ownerID;
    }

// TODO: seems like these methods are very similar

VNode.prototype.removeBefore = function(ownerID, level, index) {
      if (index === level ? 1 << level : 0 || this.array.length === 0) {
        return this;
      }
      var originIndex = (index >>> level) & MASK;
      if (originIndex >= this.array.length) {
        return new VNode([], ownerID);
      }
      var removingFirst = originIndex === 0;
      var newChild;
      if (level > 0) {
        var oldChild = this.array[originIndex];
        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
        if (newChild === oldChild && removingFirst) {
          return this;
        }
      }
      if (removingFirst && !newChild) {
        return this;
      }
      var editable = editableVNode(this, ownerID);
      if (!removingFirst) {
        for (var ii = 0; ii < originIndex; ii++) {
          editable.array[ii] = undefined;
        }
      }
      if (newChild) {
        editable.array[originIndex] = newChild;
      }
      return editable;
    };

VNode.prototype.removeAfter = function(ownerID, level, index) {
      if (index === (level ? 1 << level : 0) || this.array.length === 0) {
        return this;
      }
      var sizeIndex = ((index - 1) >>> level) & MASK;
      if (sizeIndex >= this.array.length) {
        return this;
      }

var newChild;
      if (level > 0) {
        var oldChild = this.array[sizeIndex];
        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
        if (newChild === oldChild && sizeIndex === this.array.length - 1) {
          return this;
        }
      }

var editable = editableVNode(this, ownerID);
      editable.array.splice(sizeIndex + 1);
      if (newChild) {
        editable.array[sizeIndex] = newChild;
      }
      return editable;
    };

var DONE = {};

function iterateList(list, reverse) {
    var left = list._origin;
    var right = list._capacity;
    var tailPos = getTailOffset(right);
    var tail = list._tail;

return iterateNodeOrLeaf(list._root, list._level, 0);

function iterateNodeOrLeaf(node, level, offset) {
      return level === 0 ?
        iterateLeaf(node, offset) :
        iterateNode(node, level, offset);
    }

function makeList(origin, capacity, level, root, tail, ownerID, hash) {
    var list = Object.create(ListPrototype);
    list.size = capacity - origin;
    list._origin = origin;
    list._capacity = capacity;
    list._level = level;
    list._root = root;
    list._tail = tail;
    list.__ownerID = ownerID;
    list.__hash = hash;
    list.__altered = false;
    return list;
  }

var EMPTY_LIST;
  function emptyList() {
    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
  }

function updateList(list, index, value) {
    index = wrapIndex(list, index);

if (index !== index) {
      return list;
    }

if (index >= list.size || index < 0) {
      return list.withMutations(function(list ) {
        index < 0 ?
          setListBounds(list, index).set(0, value) :
          setListBounds(list, 0, index + 1).set(index, value)
      });
    }

index += list._origin;

var newTail = list._tail;
    var newRoot = list._root;
    var didAlter = MakeRef(DID_ALTER);
    if (index >= getTailOffset(list._capacity)) {
      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);
    } else {
      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);
    }

if (!didAlter.value) {
      return list;
    }

if (list.__ownerID) {
      list._root = newRoot;
      list._tail = newTail;
      list.__hash = undefined;
      list.__altered = true;
      return list;
    }
    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);
  }

function updateVNode(node, ownerID, level, index, value, didAlter) {
    var idx = (index >>> level) & MASK;
    var nodeHas = node && idx < node.array.length;
    if (!nodeHas && value === undefined) {
      return node;
    }

var newNode;

if (level > 0) {
      var lowerNode = node && node.array[idx];
      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);
      if (newLowerNode === lowerNode) {
        return node;
      }
      newNode = editableVNode(node, ownerID);
      newNode.array[idx] = newLowerNode;
      return newNode;
    }

if (nodeHas && node.array[idx] === value) {
      return node;
    }

SetRef(didAlter);

newNode = editableVNode(node, ownerID);
    if (value === undefined && idx === newNode.array.length - 1) {
      newNode.array.pop();
    } else {
      newNode.array[idx] = value;
    }
    return newNode;
  }

function editableVNode(node, ownerID) {
    if (ownerID && node && ownerID === node.ownerID) {
      return node;
    }
    return new VNode(node ? node.array.slice() : [], ownerID);
  }

// If it's going to end after it starts, it's empty.
    if (newOrigin >= newCapacity) {
      return list.clear();
    }

var newLevel = list._level;
    var newRoot = list._root;

// New origin might need creating a higher root.
    var offsetShift = 0;
    while (newOrigin + offsetShift < 0) {
      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);
      newLevel += SHIFT;
      offsetShift += 1 << newLevel;
    }
    if (offsetShift) {
      newOrigin += offsetShift;
      oldOrigin += offsetShift;
      newCapacity += offsetShift;
      oldCapacity += offsetShift;
    }

var oldTailOffset = getTailOffset(oldCapacity);
    var newTailOffset = getTailOffset(newCapacity);

// New size might need creating a higher root.
    while (newTailOffset >= 1 << (newLevel + SHIFT)) {
      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);
      newLevel += SHIFT;
    }

// Locate or create the new tail.
    var oldTail = list._tail;
    var newTail = newTailOffset < oldTailOffset ?
      listNodeFor(list, newCapacity - 1) :
      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;

// Merge Tail into tree.
    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {
      newRoot = editableVNode(newRoot, owner);
      var node = newRoot;
      for (var level = newLevel; level > SHIFT; level -= SHIFT) {
        var idx = (oldTailOffset >>> level) & MASK;
        node = node.array[idx] = editableVNode(node.array[idx], owner);
      }
      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
    }

// If the size has been reduced, there's a chance the tail needs to be trimmed.
    if (newCapacity < oldCapacity) {
      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
    }

// If the new origin is within the tail, then we do not need a root.
    if (newOrigin >= newTailOffset) {
      newOrigin -= newTailOffset;
      newCapacity -= newTailOffset;
      newLevel = SHIFT;
      newRoot = null;
      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);

// Otherwise, if the root has been trimmed, garbage collect.
    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
      offsetShift = 0;

// Identify the new top root node of the subtree of the old root.
      while (newRoot) {
        var beginIndex = (newOrigin >>> newLevel) & MASK;
        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {
          break;
        }
        if (beginIndex) {
          offsetShift += (1 << newLevel) * beginIndex;
        }
        newLevel -= SHIFT;
        newRoot = newRoot.array[beginIndex];
      }

// Trim the new sides of the new root.
      if (newRoot && newOrigin > oldOrigin) {
        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);
      }
      if (newRoot && newTailOffset < oldTailOffset) {
        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);
      }
      if (offsetShift) {
        newOrigin -= offsetShift;
        newCapacity -= offsetShift;
      }
    }

if (list.__ownerID) {
      list.size = newCapacity - newOrigin;
      list._origin = newOrigin;
      list._capacity = newCapacity;
      list._level = newLevel;
      list._root = newRoot;
      list._tail = newTail;
      list.__hash = undefined;
      list.__altered = true;
      return list;
    }
    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
  }

function getTailOffset(size) {
    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);
  }

createClass(OrderedMap, Map);

// @pragma Construction

OrderedMap.of = function(/*...values*/) {
      return this(arguments);
    };

OrderedMap.prototype.toString = function() {
      return this.__toString('OrderedMap {', '}');
    };

// @pragma Access

OrderedMap.prototype.get = function(k, notSetValue) {
      var index = this._map.get(k);
      return index !== undefined ? this._list.get(index)[1] : notSetValue;
    };

// @pragma Modification

OrderedMap.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._map.clear();
        this._list.clear();
        return this;
      }
      return emptyOrderedMap();
    };

OrderedMap.prototype.set = function(k, v) {
      return updateOrderedMap(this, k, v);
    };

OrderedMap.prototype.remove = function(k) {
      return updateOrderedMap(this, k, NOT_SET);
    };

OrderedMap.prototype.wasAltered = function() {
      return this._map.wasAltered() || this._list.wasAltered();
    };

OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      return this._list.__iterate(
        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},
        reverse
      );
    };

OrderedMap.prototype.__iterator = function(type, reverse) {
      return this._list.fromEntrySeq().__iterator(type, reverse);
    };

OrderedMap.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      var newList = this._list.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        this._list = newList;
        return this;
      }
      return makeOrderedMap(newMap, newList, ownerID, this.__hash);
    };

function isOrderedMap(maybeOrderedMap) {
    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
  }

OrderedMap.isOrderedMap = isOrderedMap;

OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;
  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;

function makeOrderedMap(map, list, ownerID, hash) {
    var omap = Object.create(OrderedMap.prototype);
    omap.size = map ? map.size : 0;
    omap._map = map;
    omap._list = list;
    omap.__ownerID = ownerID;
    omap.__hash = hash;
    return omap;
  }

var EMPTY_ORDERED_MAP;
  function emptyOrderedMap() {
    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));
  }

createClass(ToKeyedSequence, KeyedSeq);
    function ToKeyedSequence(indexed, useKeys) {
      this._iter = indexed;
      this._useKeys = useKeys;
      this.size = indexed.size;
    }

ToKeyedSequence.prototype.get = function(key, notSetValue) {
      return this._iter.get(key, notSetValue);
    };

ToKeyedSequence.prototype.has = function(key) {
      return this._iter.has(key);
    };

ToKeyedSequence.prototype.valueSeq = function() {
      return this._iter.valueSeq();
    };

ToKeyedSequence.prototype.reverse = function() {var this$0 = this;
      var reversedSequence = reverseFactory(this, true);
      if (!this._useKeys) {
        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};
      }
      return reversedSequence;
    };

ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;
      var mappedSequence = mapFactory(this, mapper, context);
      if (!this._useKeys) {
        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};
      }
      return mappedSequence;
    };

ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      var ii;
      return this._iter.__iterate(
        this._useKeys ?
          function(v, k)  {return fn(v, k, this$0)} :
          ((ii = reverse ? resolveSize(this) : 0),
            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),
        reverse
      );
    };

ToKeyedSequence.prototype.__iterator = function(type, reverse) {
      if (this._useKeys) {
        return this._iter.__iterator(type, reverse);
      }
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var ii = reverse ? resolveSize(this) : 0;
      return new Iterator(function()  {
        var step = iterator.next();
        return step.done ? step :
          iteratorValue(type, reverse ? --ii : ii++, step.value, step);
      });
    };

ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;

createClass(ToIndexedSequence, IndexedSeq);
    function ToIndexedSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

ToIndexedSequence.prototype.includes = function(value) {
      return this._iter.includes(value);
    };

ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      var iterations = 0;
      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);
    };

ToIndexedSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var iterations = 0;
      return new Iterator(function()  {
        var step = iterator.next();
        return step.done ? step :
          iteratorValue(type, iterations++, step.value, step)
      });
    };

createClass(ToSetSequence, SetSeq);
    function ToSetSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

ToSetSequence.prototype.has = function(key) {
      return this._iter.includes(key);
    };

ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);
    };

ToSetSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function()  {
        var step = iterator.next();
        return step.done ? step :
          iteratorValue(type, step.value, step.value, step);
      });
    };

createClass(FromEntriesSequence, KeyedSeq);
    function FromEntriesSequence(entries) {
      this._iter = entries;
      this.size = entries.size;
    }

FromEntriesSequence.prototype.entrySeq = function() {
      return this._iter.toSeq();
    };

FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      return this._iter.__iterate(function(entry ) {
        // Check if entry exists first so array access doesn't throw for holes
        // in the parent iteration.
        if (entry) {
          validateEntry(entry);
          var indexedIterable = isIterable(entry);
          return fn(
            indexedIterable ? entry.get(1) : entry[1],
            indexedIterable ? entry.get(0) : entry[0],
            this$0
          );
        }
      }, reverse);
    };

FromEntriesSequence.prototype.__iterator = function(type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function()  {
        while (true) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          // Check if entry exists first so array access doesn't throw for holes
          // in the parent iteration.
          if (entry) {
            validateEntry(entry);
            var indexedIterable = isIterable(entry);
            return iteratorValue(
              type,
              indexedIterable ? entry.get(0) : entry[0],
              indexedIterable ? entry.get(1) : entry[1],
              step
            );
          }
        }
      });
    };

ToIndexedSequence.prototype.cacheResult =
  ToKeyedSequence.prototype.cacheResult =
  ToSetSequence.prototype.cacheResult =
  FromEntriesSequence.prototype.cacheResult =
    cacheResultThrough;

function sliceFactory(iterable, begin, end, useKeys) {
    var originalSize = iterable.size;

// Sanitize begin & end using this shorthand for ToInt32(argument)
    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
    if (begin !== undefined) {
      begin = begin | 0;
    }
    if (end !== undefined) {
      if (end === Infinity) {
        end = originalSize;
      } else {
        end = end | 0;
      }
    }

if (wholeSlice(begin, end, originalSize)) {
      return iterable;
    }

var resolvedBegin = resolveBegin(begin, originalSize);
    var resolvedEnd = resolveEnd(end, originalSize);

// begin or end will be NaN if they were provided as negative numbers and
    // this iterable's size is unknown. In that case, cache first so there is
    // a known size and these do not resolve to NaN.
    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);
    }

// Note: resolvedEnd is undefined when the original sequence's length is
    // unknown and this slice did not supply an end and should contain all
    // elements after resolvedBegin.
    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
    var resolvedSize = resolvedEnd - resolvedBegin;
    var sliceSize;
    if (resolvedSize === resolvedSize) {
      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
    }

var sliceSeq = makeSequence(iterable);

// If iterable.size is undefined, the size of the realized sliceSeq is
    // unknown at this point unless the number of items to slice is 0
    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;

if (!useKeys && isSeq(iterable) && sliceSize >= 0) {
      sliceSeq.get = function (index, notSetValue) {
        index = wrapIndex(this, index);
        return index >= 0 && index < sliceSize ?
          iterable.get(index + resolvedBegin, notSetValue) :
          notSetValue;
      }
    }

sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;
      if (sliceSize === 0) {
        return 0;
      }
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var skipped = 0;
      var isSkipping = true;
      var iterations = 0;
      iterable.__iterate(function(v, k)  {
        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
          iterations++;
          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&
                 iterations !== sliceSize;
        }
      });
      return iterations;
    };

sliceSeq.__iteratorUncached = function(type, reverse) {
      if (sliceSize !== 0 && reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      // Don't bother instantiating parent iterator if taking 0.
      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);
      var skipped = 0;
      var iterations = 0;
      return new Iterator(function()  {
        while (skipped++ < resolvedBegin) {
          iterator.next();
        }
        if (++iterations > sliceSize) {
          return iteratorDone();
        }
        var step = iterator.next();
        if (useKeys || type === ITERATE_VALUES) {
          return step;
        } else if (type === ITERATE_KEYS) {
          return iteratorValue(type, iterations - 1, undefined, step);
        } else {
          return iteratorValue(type, iterations - 1, step.value[1], step);
        }
      });
    }

return sliceSeq;
  }

if (iters.length === 0) {
      return iterable;
    }

if (iters.length === 1) {
      var singleton = iters[0];
      if (singleton === iterable ||
          isKeyedIterable && isKeyed(singleton) ||
          isIndexed(iterable) && isIndexed(singleton)) {
        return singleton;
      }
    }

function flatMapFactory(iterable, mapper, context) {
    var coerce = iterableClass(iterable);
    return iterable.toSeq().map(
      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}
    ).flatten(true);
  }

function maxCompare(comparator, a, b) {
    var comp = comparator(b, a);
    // b is considered the new max if the comparator declares them equal, but
    // they are not equal and b is in fact a nullish value.
    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;
  }

// #pragma Helper Functions

function reify(iter, seq) {
    return isSeq(iter) ? seq : iter.constructor(seq);
  }

function validateEntry(entry) {
    if (entry !== Object(entry)) {
      throw new TypeError('Expected [K, V] tuple: ' + entry);
    }
  }

function resolveSize(iter) {
    assertNotInfinite(iter.size);
    return ensureSize(iter);
  }

function iterableClass(iterable) {
    return isKeyed(iterable) ? KeyedIterable :
      isIndexed(iterable) ? IndexedIterable :
      SetIterable;
  }

function makeSequence(iterable) {
    return Object.create(
      (
        isKeyed(iterable) ? KeyedSeq :
        isIndexed(iterable) ? IndexedSeq :
        SetSeq
      ).prototype
    );
  }

function defaultComparator(a, b) {
    return a > b ? 1 : a < b ? -1 : 0;
  }

createClass(Record, KeyedCollection);

function Record(defaultValues, name) {
      var hasInitialized;

var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);
      RecordTypePrototype.constructor = RecordType;

return RecordType;
    }

Record.prototype.toString = function() {
      return this.__toString(recordName(this) + ' {', '}');
    };

// @pragma Access

Record.prototype.has = function(k) {
      return this._defaultValues.hasOwnProperty(k);
    };

Record.prototype.get = function(k, notSetValue) {
      if (!this.has(k)) {
        return notSetValue;
      }
      var defaultVal = this._defaultValues[k];
      return this._map ? this._map.get(k, defaultVal) : defaultVal;
    };

// @pragma Modification

Record.prototype.clear = function() {
      if (this.__ownerID) {
        this._map && this._map.clear();
        return this;
      }
      var RecordType = this.constructor;
      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));
    };

Record.prototype.set = function(k, v) {
      if (!this.has(k)) {
        throw new Error('Cannot set unknown key "' + k + '" on ' + recordName(this));
      }
      if (this._map && !this._map.has(k)) {
        var defaultVal = this._defaultValues[k];
        if (v === defaultVal) {
          return this;
        }
      }
      var newMap = this._map && this._map.set(k, v);
      if (this.__ownerID || newMap === this._map) {
        return this;
      }
      return makeRecord(this, newMap);
    };

Record.prototype.remove = function(k) {
      if (!this.has(k)) {
        return this;
      }
      var newMap = this._map && this._map.remove(k);
      if (this.__ownerID || newMap === this._map) {
        return this;
      }
      return makeRecord(this, newMap);
    };

Record.prototype.wasAltered = function() {
      return this._map.wasAltered();
    };

Record.prototype.__iterator = function(type, reverse) {var this$0 = this;
      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);
    };

Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);
    };

Record.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map && this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return makeRecord(this, newMap, ownerID);
    };

var RecordPrototype = Record.prototype;
  RecordPrototype[DELETE] = RecordPrototype.remove;
  RecordPrototype.deleteIn =
  RecordPrototype.removeIn = MapPrototype.removeIn;
  RecordPrototype.merge = MapPrototype.merge;
  RecordPrototype.mergeWith = MapPrototype.mergeWith;
  RecordPrototype.mergeIn = MapPrototype.mergeIn;
  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;
  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;
  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
  RecordPrototype.setIn = MapPrototype.setIn;
  RecordPrototype.update = MapPrototype.update;
  RecordPrototype.updateIn = MapPrototype.updateIn;
  RecordPrototype.withMutations = MapPrototype.withMutations;
  RecordPrototype.asMutable = MapPrototype.asMutable;
  RecordPrototype.asImmutable = MapPrototype.asImmutable;

function makeRecord(likeRecord, map, ownerID) {
    var record = Object.create(Object.getPrototypeOf(likeRecord));
    record._map = map;
    record.__ownerID = ownerID;
    return record;
  }

function recordName(record) {
    return record._name || record.constructor.name || 'Record';
  }

function setProps(prototype, names) {
    try {
      names.forEach(setProp.bind(undefined, prototype));
    } catch (error) {
      // Object.defineProperty failed. Probably IE8.
    }
  }

createClass(Set, SetCollection);

// @pragma Construction

Set.of = function(/*...values*/) {
      return this(arguments);
    };

Set.fromKeys = function(value) {
      return this(KeyedIterable(value).keySeq());
    };

Set.prototype.toString = function() {
      return this.__toString('Set {', '}');
    };

// @pragma Access

Set.prototype.has = function(value) {
      return this._map.has(value);
    };

// @pragma Modification

Set.prototype.add = function(value) {
      return updateSet(this, this._map.set(value, true));
    };

Set.prototype.remove = function(value) {
      return updateSet(this, this._map.remove(value));
    };

Set.prototype.clear = function() {
      return updateSet(this, this._map.clear());
    };

// @pragma Composition

Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);
      iters = iters.filter(function(x ) {return x.size !== 0});
      if (iters.length === 0) {
        return this;
      }
      if (this.size === 0 && !this.__ownerID && iters.length === 1) {
        return this.constructor(iters[0]);
      }
      return this.withMutations(function(set ) {
        for (var ii = 0; ii < iters.length; ii++) {
          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});
        }
      });
    };

Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);
      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function(iter ) {return SetIterable(iter)});
      var originalSet = this;
      return this.withMutations(function(set ) {
        originalSet.forEach(function(value ) {
          if (!iters.every(function(iter ) {return iter.includes(value)})) {
            set.remove(value);
          }
        });
      });
    };

Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);
      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function(iter ) {return SetIterable(iter)});
      var originalSet = this;
      return this.withMutations(function(set ) {
        originalSet.forEach(function(value ) {
          if (iters.some(function(iter ) {return iter.includes(value)})) {
            set.remove(value);
          }
        });
      });
    };

Set.prototype.merge = function() {
      return this.union.apply(this, arguments);
    };

Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
      return this.union.apply(this, iters);
    };

Set.prototype.sort = function(comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator));
    };

Set.prototype.sortBy = function(mapper, comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator, mapper));
    };

Set.prototype.wasAltered = function() {
      return this._map.wasAltered();
    };

Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;
      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);
    };

Set.prototype.__iterator = function(type, reverse) {
      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);
    };

Set.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return this.__make(newMap, ownerID);
    };

function isSet(maybeSet) {
    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);
  }

Set.isSet = isSet;

var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';

var SetPrototype = Set.prototype;
  SetPrototype[IS_SET_SENTINEL] = true;
  SetPrototype[DELETE] = SetPrototype.remove;
  SetPrototype.mergeDeep = SetPrototype.merge;
  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;
  SetPrototype.withMutations = MapPrototype.withMutations;
  SetPrototype.asMutable = MapPrototype.asMutable;
  SetPrototype.asImmutable = MapPrototype.asImmutable;

SetPrototype.__empty = emptySet;
  SetPrototype.__make = makeSet;

function updateSet(set, newMap) {
    if (set.__ownerID) {
      set.size = newMap.size;
      set._map = newMap;
      return set;
    }
    return newMap === set._map ? set :
      newMap.size === 0 ? set.__empty() :
      set.__make(newMap);
  }

function makeSet(map, ownerID) {
    var set = Object.create(SetPrototype);
    set.size = map ? map.size : 0;
    set._map = map;
    set.__ownerID = ownerID;
    return set;
  }

var EMPTY_SET;
  function emptySet() {
    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
  }

createClass(OrderedSet, Set);

// @pragma Construction

OrderedSet.of = function(/*...values*/) {
      return this(arguments);
    };

OrderedSet.fromKeys = function(value) {
      return this(KeyedIterable(value).keySeq());
    };

OrderedSet.prototype.toString = function() {
      return this.__toString('OrderedSet {', '}');
    };

function isOrderedSet(maybeOrderedSet) {
    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
  }

OrderedSet.isOrderedSet = isOrderedSet;

var OrderedSetPrototype = OrderedSet.prototype;
  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;

OrderedSetPrototype.__empty = emptyOrderedSet;
  OrderedSetPrototype.__make = makeOrderedSet;

function makeOrderedSet(map, ownerID) {
    var set = Object.create(OrderedSetPrototype);
    set.size = map ? map.size : 0;
    set._map = map;
    set.__ownerID = ownerID;
    return set;
  }

var EMPTY_ORDERED_SET;
  function emptyOrderedSet() {
    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));
  }

createClass(Stack, IndexedCollection);

// @pragma Construction

function Stack(value) {
      return value === null || value === undefined ? emptyStack() :
        isStack(value) ? value :
        emptyStack().unshiftAll(value);
    }

Stack.of = function(/*...values*/) {
      return this(arguments);
    };

Stack.prototype.toString = function() {
      return this.__toString('Stack [', ']');
    };

// @pragma Access

Stack.prototype.get = function(index, notSetValue) {
      var head = this._head;
      index = wrapIndex(this, index);
      while (head && index--) {
        head = head.next;
      }
      return head ? head.value : notSetValue;
    };

Stack.prototype.peek = function() {
      return this._head && this._head.value;
    };

// @pragma Modification

Stack.prototype.push = function(/*...values*/) {
      if (arguments.length === 0) {
        return this;
      }
      var newSize = this.size + arguments.length;
      var head = this._head;
      for (var ii = arguments.length - 1; ii >= 0; ii--) {
        head = {
          value: arguments[ii],
          next: head
        };
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

Stack.prototype.pushAll = function(iter) {
      iter = IndexedIterable(iter);
      if (iter.size === 0) {
        return this;
      }
      assertNotInfinite(iter.size);
      var newSize = this.size;
      var head = this._head;
      iter.reverse().forEach(function(value ) {
        newSize++;
        head = {
          value: value,
          next: head
        };
      });
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

Stack.prototype.pop = function() {
      return this.slice(1);
    };

Stack.prototype.unshift = function(/*...values*/) {
      return this.push.apply(this, arguments);
    };

Stack.prototype.unshiftAll = function(iter) {
      return this.pushAll(iter);
    };

Stack.prototype.shift = function() {
      return this.pop.apply(this, arguments);
    };

Stack.prototype.clear = function() {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._head = undefined;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyStack();
    };

Stack.prototype.slice = function(begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      var resolvedBegin = resolveBegin(begin, this.size);
      var resolvedEnd = resolveEnd(end, this.size);
      if (resolvedEnd !== this.size) {
        // super.slice(begin, end);
        return IndexedCollection.prototype.slice.call(this, begin, end);
      }
      var newSize = this.size - resolvedBegin;
      var head = this._head;
      while (resolvedBegin--) {
        head = head.next;
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

// @pragma Mutability

Stack.prototype.__ensureOwner = function(ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeStack(this.size, this._head, ownerID, this.__hash);
    };

// @pragma Iteration

Stack.prototype.__iterate = function(fn, reverse) {
      if (reverse) {
        return this.reverse().__iterate(fn);
      }
      var iterations = 0;
      var node = this._head;
      while (node) {
        if (fn(node.value, iterations++, this) === false) {
          break;
        }
        node = node.next;
      }
      return iterations;
    };

Stack.prototype.__iterator = function(type, reverse) {
      if (reverse) {
        return this.reverse().__iterator(type);
      }
      var iterations = 0;
      var node = this._head;
      return new Iterator(function()  {
        if (node) {
          var value = node.value;
          node = node.next;
          return iteratorValue(type, iterations++, value);
        }
        return iteratorDone();
      });
    };

function isStack(maybeStack) {
    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);
  }

Stack.isStack = isStack;

var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';

var StackPrototype = Stack.prototype;
  StackPrototype[IS_STACK_SENTINEL] = true;
  StackPrototype.withMutations = MapPrototype.withMutations;
  StackPrototype.asMutable = MapPrototype.asMutable;
  StackPrototype.asImmutable = MapPrototype.asImmutable;
  StackPrototype.wasAltered = MapPrototype.wasAltered;

function makeStack(size, head, ownerID, hash) {
    var map = Object.create(StackPrototype);
    map.size = size;
    map._head = head;
    map.__ownerID = ownerID;
    map.__hash = hash;
    map.__altered = false;
    return map;
  }

var EMPTY_STACK;
  function emptyStack() {
    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
  }

/**
   * Contributes additional methods to a constructor
   */
  function mixin(ctor, methods) {
    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };
    Object.keys(methods).forEach(keyCopier);
    Object.getOwnPropertySymbols &&
      Object.getOwnPropertySymbols(methods).forEach(keyCopier);
    return ctor;
  }

Iterable.Iterator = Iterator;

mixin(Iterable, {

// ### Conversion to other types

toArray: function() {
      assertNotInfinite(this.size);
      var array = new Array(this.size || 0);
      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });
      return array;
    },

toIndexedSeq: function() {
      return new ToIndexedSequence(this);
    },

toJS: function() {
      return this.toSeq().map(
        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}
      ).__toJS();
    },

toJSON: function() {
      return this.toSeq().map(
        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}
      ).__toJS();
    },

toKeyedSeq: function() {
      return new ToKeyedSequence(this, true);
    },

toMap: function() {
      // Use Late Binding here to solve the circular dependency.
      return Map(this.toKeyedSeq());
    },

toObject: function() {
      assertNotInfinite(this.size);
      var object = {};
      this.__iterate(function(v, k)  { object[k] = v; });
      return object;
    },

toOrderedMap: function() {
      // Use Late Binding here to solve the circular dependency.
      return OrderedMap(this.toKeyedSeq());
    },

toOrderedSet: function() {
      // Use Late Binding here to solve the circular dependency.
      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
    },

toSet: function() {
      // Use Late Binding here to solve the circular dependency.
      return Set(isKeyed(this) ? this.valueSeq() : this);
    },

toSetSeq: function() {
      return new ToSetSequence(this);
    },

toSeq: function() {
      return isIndexed(this) ? this.toIndexedSeq() :
        isKeyed(this) ? this.toKeyedSeq() :
        this.toSetSeq();
    },

toStack: function() {
      // Use Late Binding here to solve the circular dependency.
      return Stack(isKeyed(this) ? this.valueSeq() : this);
    },

toList: function() {
      // Use Late Binding here to solve the circular dependency.
      return List(isKeyed(this) ? this.valueSeq() : this);
    },

// ### Common JavaScript methods and properties

toString: function() {
      return '[Iterable]';
    },

__toString: function(head, tail) {
      if (this.size === 0) {
        return head + tail;
      }
      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;
    },

// ### ES6 Collection methods (ES6 Array and Map)

concat: function() {var values = SLICE$0.call(arguments, 0);
      return reify(this, concatFactory(this, values));
    },

includes: function(searchValue) {
      return this.some(function(value ) {return is(value, searchValue)});
    },

entries: function() {
      return this.__iterator(ITERATE_ENTRIES);
    },

every: function(predicate, context) {
      assertNotInfinite(this.size);
      var returnValue = true;
      this.__iterate(function(v, k, c)  {
        if (!predicate.call(context, v, k, c)) {
          returnValue = false;
          return false;
        }
      });
      return returnValue;
    },

filter: function(predicate, context) {
      return reify(this, filterFactory(this, predicate, context, true));
    },

find: function(predicate, context, notSetValue) {
      var entry = this.findEntry(predicate, context);
      return entry ? entry[1] : notSetValue;
    },

forEach: function(sideEffect, context) {
      assertNotInfinite(this.size);
      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
    },

join: function(separator) {
      assertNotInfinite(this.size);
      separator = separator !== undefined ? '' + separator : ',';
      var joined = '';
      var isFirst = true;
      this.__iterate(function(v ) {
        isFirst ? (isFirst = false) : (joined += separator);
        joined += v !== null && v !== undefined ? v.toString() : '';
      });
      return joined;
    },

keys: function() {
      return this.__iterator(ITERATE_KEYS);
    },

map: function(mapper, context) {
      return reify(this, mapFactory(this, mapper, context));
    },

reduce: function(reducer, initialReduction, context) {
      assertNotInfinite(this.size);
      var reduction;
      var useFirst;
      if (arguments.length < 2) {
        useFirst = true;
      } else {
        reduction = initialReduction;
      }
      this.__iterate(function(v, k, c)  {
        if (useFirst) {
          useFirst = false;
          reduction = v;
        } else {
          reduction = reducer.call(context, reduction, v, k, c);
        }
      });
      return reduction;
    },

reduceRight: function(reducer, initialReduction, context) {
      var reversed = this.toKeyedSeq().reverse();
      return reversed.reduce.apply(reversed, arguments);
    },

reverse: function() {
      return reify(this, reverseFactory(this, true));
    },

slice: function(begin, end) {
      return reify(this, sliceFactory(this, begin, end, true));
    },

some: function(predicate, context) {
      return !this.every(not(predicate), context);
    },

sort: function(comparator) {
      return reify(this, sortFactory(this, comparator));
    },

values: function() {
      return this.__iterator(ITERATE_VALUES);
    },

// ### More sequential methods

butLast: function() {
      return this.slice(0, -1);
    },

isEmpty: function() {
      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});
    },

count: function(predicate, context) {
      return ensureSize(
        predicate ? this.toSeq().filter(predicate, context) : this
      );
    },

countBy: function(grouper, context) {
      return countByFactory(this, grouper, context);
    },

equals: function(other) {
      return deepEqual(this, other);
    },

entrySeq: function() {
      var iterable = this;
      if (iterable._cache) {
        // We cache as an entries array, so we can just return the cache!
        return new ArraySeq(iterable._cache);
      }
      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();
      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};
      return entriesSequence;
    },

filterNot: function(predicate, context) {
      return this.filter(not(predicate), context);
    },

findEntry: function(predicate, context, notSetValue) {
      var found = notSetValue;
      this.__iterate(function(v, k, c)  {
        if (predicate.call(context, v, k, c)) {
          found = [k, v];
          return false;
        }
      });
      return found;
    },

findKey: function(predicate, context) {
      var entry = this.findEntry(predicate, context);
      return entry && entry[0];
    },

findLast: function(predicate, context, notSetValue) {
      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);
    },

findLastEntry: function(predicate, context, notSetValue) {
      return this.toKeyedSeq().reverse().findEntry(predicate, context, notSetValue);
    },

findLastKey: function(predicate, context) {
      return this.toKeyedSeq().reverse().findKey(predicate, context);
    },

first: function() {
      return this.find(returnTrue);
    },

flatMap: function(mapper, context) {
      return reify(this, flatMapFactory(this, mapper, context));
    },

flatten: function(depth) {
      return reify(this, flattenFactory(this, depth, true));
    },

fromEntrySeq: function() {
      return new FromEntriesSequence(this);
    },

get: function(searchKey, notSetValue) {
      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);
    },

getIn: function(searchKeyPath, notSetValue) {
      var nested = this;
      // Note: in an ES6 environment, we would prefer:
      // for (var key of searchKeyPath) {
      var iter = forceIterator(searchKeyPath);
      var step;
      while (!(step = iter.next()).done) {
        var key = step.value;
        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;
        if (nested === NOT_SET) {
          return notSetValue;
        }
      }
      return nested;
    },

groupBy: function(grouper, context) {
      return groupByFactory(this, grouper, context);
    },

has: function(searchKey) {
      return this.get(searchKey, NOT_SET) !== NOT_SET;
    },

hasIn: function(searchKeyPath) {
      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;
    },

isSubset: function(iter) {
      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);
      return this.every(function(value ) {return iter.includes(value)});
    },

isSuperset: function(iter) {
      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);
      return iter.isSubset(this);
    },

keyOf: function(searchValue) {
      return this.findKey(function(value ) {return is(value, searchValue)});
    },

keySeq: function() {
      return this.toSeq().map(keyMapper).toIndexedSeq();
    },

last: function() {
      return this.toSeq().reverse().first();
    },

lastKeyOf: function(searchValue) {
      return this.toKeyedSeq().reverse().keyOf(searchValue);
    },

max: function(comparator) {
      return maxFactory(this, comparator);
    },

maxBy: function(mapper, comparator) {
      return maxFactory(this, comparator, mapper);
    },

min: function(comparator) {
      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);
    },

minBy: function(mapper, comparator) {
      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);
    },

rest: function() {
      return this.slice(1);
    },

skip: function(amount) {
      return this.slice(Math.max(0, amount));
    },

skipLast: function(amount) {
      return reify(this, this.toSeq().reverse().skip(amount).reverse());
    },

skipWhile: function(predicate, context) {
      return reify(this, skipWhileFactory(this, predicate, context, true));
    },

skipUntil: function(predicate, context) {
      return this.skipWhile(not(predicate), context);
    },

sortBy: function(mapper, comparator) {
      return reify(this, sortFactory(this, comparator, mapper));
    },

take: function(amount) {
      return this.slice(0, Math.max(0, amount));
    },

takeLast: function(amount) {
      return reify(this, this.toSeq().reverse().take(amount).reverse());
    },

takeWhile: function(predicate, context) {
      return reify(this, takeWhileFactory(this, predicate, context));
    },

takeUntil: function(predicate, context) {
      return this.takeWhile(not(predicate), context);
    },

valueSeq: function() {
      return this.toIndexedSeq();
    },

// ### Hashable Object

hashCode: function() {
      return this.__hash || (this.__hash = hashIterable(this));
    }

// ### Internal

// abstract __iterate(fn, reverse)

// abstract __iterator(type, reverse)
  });

// var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';

var IterablePrototype = Iterable.prototype;
  IterablePrototype[IS_ITERABLE_SENTINEL] = true;
  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;
  IterablePrototype.__toJS = IterablePrototype.toArray;
  IterablePrototype.__toStringMapper = quoteString;
  IterablePrototype.inspect =
  IterablePrototype.toSource = function() { return this.toString(); };
  IterablePrototype.chain = IterablePrototype.flatMap;
  IterablePrototype.contains = IterablePrototype.includes;

mixin(KeyedIterable, {

// ### More sequential methods

flip: function() {
      return reify(this, flipFactory(this));
    },

mapEntries: function(mapper, context) {var this$0 = this;
      var iterations = 0;
      return reify(this,
        this.toSeq().map(
          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}
        ).fromEntrySeq()
      );
    },

mapKeys: function(mapper, context) {var this$0 = this;
      return reify(this,
        this.toSeq().flip().map(
          function(k, v)  {return mapper.call(context, k, v, this$0)}
        ).flip()
      );
    }

});

var KeyedIterablePrototype = KeyedIterable.prototype;
  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;
  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;
  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;
  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};

mixin(IndexedIterable, {

// ### Conversion to other types

toKeyedSeq: function() {
      return new ToKeyedSequence(this, false);
    },

// ### ES6 Collection methods (ES6 Array and Map)

filter: function(predicate, context) {
      return reify(this, filterFactory(this, predicate, context, false));
    },

findIndex: function(predicate, context) {
      var entry = this.findEntry(predicate, context);
      return entry ? entry[0] : -1;
    },

indexOf: function(searchValue) {
      var key = this.keyOf(searchValue);
      return key === undefined ? -1 : key;
    },

lastIndexOf: function(searchValue) {
      var key = this.lastKeyOf(searchValue);
      return key === undefined ? -1 : key;
    },

reverse: function() {
      return reify(this, reverseFactory(this, false));
    },

slice: function(begin, end) {
      return reify(this, sliceFactory(this, begin, end, false));
    },

splice: function(index, removeNum /*, ...values*/) {
      var numArgs = arguments.length;
      removeNum = Math.max(removeNum | 0, 0);
      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
        return this;
      }
      // If index is negative, it should resolve relative to the size of the
      // collection. However size may be expensive to compute if not cached, so
      // only call count() if the number is in fact negative.
      index = resolveBegin(index, index < 0 ? this.count() : this.size);
      var spliced = this.slice(0, index);
      return reify(
        this,
        numArgs === 1 ?
          spliced :
          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))
      );
    },

// ### More collection methods

findLastIndex: function(predicate, context) {
      var entry = this.findLastEntry(predicate, context);
      return entry ? entry[0] : -1;
    },

first: function() {
      return this.get(0);
    },

flatten: function(depth) {
      return reify(this, flattenFactory(this, depth, false));
    },

get: function(index, notSetValue) {
      index = wrapIndex(this, index);
      return (index < 0 || (this.size === Infinity ||
          (this.size !== undefined && index > this.size))) ?
        notSetValue :
        this.find(function(_, key)  {return key === index}, undefined, notSetValue);
    },

has: function(index) {
      index = wrapIndex(this, index);
      return index >= 0 && (this.size !== undefined ?
        this.size === Infinity || index < this.size :
        this.indexOf(index) !== -1
      );
    },

interpose: function(separator) {
      return reify(this, interposeFactory(this, separator));
    },

interleave: function(/*...iterables*/) {
      var iterables = [this].concat(arrCopy(arguments));
      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);
      var interleaved = zipped.flatten(true);
      if (zipped.size) {
        interleaved.size = zipped.size * iterables.length;
      }
      return reify(this, interleaved);
    },

keySeq: function() {
      return Range(0, this.size);
    },

last: function() {
      return this.get(-1);
    },

skipWhile: function(predicate, context) {
      return reify(this, skipWhileFactory(this, predicate, context, false));
    },

zip: function(/*, ...iterables */) {
      var iterables = [this].concat(arrCopy(arguments));
      return reify(this, zipWithFactory(this, defaultZipper, iterables));
    },

zipWith: function(zipper/*, ...iterables */) {
      var iterables = arrCopy(arguments);
      iterables[0] = this;
      return reify(this, zipWithFactory(this, zipper, iterables));
    }

});

IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;
  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;

mixin(SetIterable, {

// ### ES6 Collection methods (ES6 Array and Map)

get: function(value, notSetValue) {
      return this.has(value) ? value : notSetValue;
    },

includes: function(value) {
      return this.has(value);
    },

// ### More sequential methods

keySeq: function() {
      return this.valueSeq();
    }

});

SetIterable.prototype.has = IterablePrototype.includes;
  SetIterable.prototype.contains = SetIterable.prototype.includes;

// Mixin subclasses

mixin(KeyedSeq, KeyedIterable.prototype);
  mixin(IndexedSeq, IndexedIterable.prototype);
  mixin(SetSeq, SetIterable.prototype);

mixin(KeyedCollection, KeyedIterable.prototype);
  mixin(IndexedCollection, IndexedIterable.prototype);
  mixin(SetCollection, SetIterable.prototype);

// #pragma Helper functions

function keyMapper(v, k) {
    return k;
  }

function entryMapper(v, k) {
    return [k, v];
  }

function not(predicate) {
    return function() {
      return !predicate.apply(this, arguments);
    }
  }

function neg(predicate) {
    return function() {
      return -predicate.apply(this, arguments);
    }
  }

function quoteString(value) {
    return typeof value === 'string' ? JSON.stringify(value) : String(value);
  }

function defaultZipper() {
    return arrCopy(arguments);
  }

function defaultNegComparator(a, b) {
    return a < b ? 1 : a > b ? -1 : 0;
  }

function murmurHashOfSize(size, h) {
    h = imul(h, 0xCC9E2D51);
    h = imul(h << 15 | h >>> -15, 0x1B873593);
    h = imul(h << 13 | h >>> -13, 5);
    h = (h + 0xE6546B64 | 0) ^ size;
    h = imul(h ^ h >>> 16, 0x85EBCA6B);
    h = imul(h ^ h >>> 13, 0xC2B2AE35);
    h = smi(h ^ h >>> 16);
    return h;
  }

function hashMerge(a, b) {
    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int
  }

var Immutable = {

Iterable: Iterable,

Seq: Seq,
    Collection: Collection,
    Map: Map,
    OrderedMap: OrderedMap,
    List: List,
    Stack: Stack,
    Set: Set,
    OrderedSet: OrderedSet,

Record: Record,
    Range: Range,
    Repeat: Repeat,

is: is,
    fromJS: fromJS

};

return Immutable;

}));

/***/ }),
/* 956 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var hasToStringTag = __webpack_require__(266)();
var callBound = __webpack_require__(385);

var $toString = callBound('Object.prototype.toString');

var isStandardArguments = function isArguments(value) {
	if (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {
		return false;
	}
	return $toString(value) === '[object Arguments]';
};

var isLegacyArguments = function isArguments(value) {
	if (isStandardArguments(value)) {
		return true;
	}
	return value !== null &&
		typeof value === 'object' &&
		typeof value.length === 'number' &&
		value.length >= 0 &&
		$toString(value) !== '[object Array]' &&
		$toString(value.callee) === '[object Function]';
};

var supportsStandardArguments = (function () {
	return isStandardArguments(arguments);
}());

isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests

module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;

/***/ }),
/* 957 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var getDay = Date.prototype.getDay;
var tryDateObject = function tryDateGetDayCall(value) {
	try {
		getDay.call(value);
		return true;
	} catch (e) {
		return false;
	}
};

var toStr = Object.prototype.toString;
var dateClass = '[object Date]';
var hasToStringTag = __webpack_require__(266)();

module.exports = function isDateObject(value) {
	if (typeof value !== 'object' || value === null) {
		return false;
	}
	return hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;
};

/***/ }),
/* 958 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = function isNegativeZero(number) {
	return number === 0 && (1 / number) === -Infinity;
};

/***/ }),
/* 959 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var callBound = __webpack_require__(385);
var hasToStringTag = __webpack_require__(266)();
var has;
var $exec;
var isRegexMarker;
var badStringifier;

if (hasToStringTag) {
	has = callBound('Object.prototype.hasOwnProperty');
	$exec = callBound('RegExp.prototype.exec');
	isRegexMarker = {};

var throwRegexMarker = function () {
		throw isRegexMarker;
	};
	badStringifier = {
		toString: throwRegexMarker,
		valueOf: throwRegexMarker
	};

if (typeof Symbol.toPrimitive === 'symbol') {
		badStringifier[Symbol.toPrimitive] = throwRegexMarker;
	}
}

var $toString = callBound('Object.prototype.toString');
var gOPD = Object.getOwnPropertyDescriptor;
var regexClass = '[object RegExp]';

module.exports = hasToStringTag
	// eslint-disable-next-line consistent-return
	? function isRegex(value) {
		if (!value || typeof value !== 'object') {
			return false;
		}

var descriptor = gOPD(value, 'lastIndex');
		var hasLastIndexDataProperty = descriptor && has(descriptor, 'value');
		if (!hasLastIndexDataProperty) {
			return false;
		}

try {
			$exec(value, badStringifier);
		} catch (e) {
			return e === isRegexMarker;
		}
	}
	: function isRegex(value) {
		// In older browsers, typeof regex incorrectly returns 'function'
		if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
			return false;
		}

return $toString(value) === regexClass;
	};

/***/ }),
/* 960 */
/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = Array.isArray || function (arr) {
  return toString.call(arr) == '[object Array]';
};

/***/ }),
/* 961 */
/***/ (function(module, exports, __webpack_require__) {

var camel2hyphen = __webpack_require__(1452);

var isDimension = function (feature) {
  var re = /[height|width]$/;
  return re.test(feature);
};

module.exports = json2mq;

/***/ }),
/* 962 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {/**
 * lodash (Custom Build) <https://lodash.com/>
 * Build: `lodash modularize exports="npm" -o ./`
 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';

/** Used as references for various `Number` constants. */
var NAN = 0 / 0;

/** `Object#toString` result references. */
var symbolTag = '[object Symbol]';

/** Used to match leading and trailing whitespace. */
var reTrim = /^\s+|\s+$/g;

/** Used to detect bad signed hexadecimal string values. */
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

/** Used to detect binary string values. */
var reIsBinary = /^0b[01]+$/i;

/** Used to detect octal string values. */
var reIsOctal = /^0o[0-7]+$/i;

/** Built-in method references without a dependency on `root`. */
var freeParseInt = parseInt;

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

/** Used for built-in method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var objectToString = objectProto.toString;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max,
    nativeMin = Math.min;

/**
 * Gets the timestamp of the number of milliseconds that have elapsed since
 * the Unix epoch (1 January 1970 00:00:00 UTC).
 *
 * @static
 * @memberOf _
 * @since 2.4.0
 * @category Date
 * @returns {number} Returns the timestamp.
 * @example
 *
 * _.defer(function(stamp) {
 *   console.log(_.now() - stamp);
 * }, _.now());
 * // => Logs the number of milliseconds it took for the deferred invocation.
 */
var now = function() {
  return root.Date.now();
};

function invokeFunc(time) {
    var args = lastArgs,
        thisArg = lastThis;

lastArgs = lastThis = undefined;
    lastInvokeTime = time;
    result = func.apply(thisArg, args);
    return result;
  }

function remainingWait(time) {
    var timeSinceLastCall = time - lastCallTime,
        timeSinceLastInvoke = time - lastInvokeTime,
        result = wait - timeSinceLastCall;

return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
  }

function shouldInvoke(time) {
    var timeSinceLastCall = time - lastCallTime,
        timeSinceLastInvoke = time - lastInvokeTime;

function trailingEdge(time) {
    timerId = undefined;

function cancel() {
    if (timerId !== undefined) {
      clearTimeout(timerId);
    }
    lastInvokeTime = 0;
    lastArgs = lastCallTime = lastThis = timerId = undefined;
  }

function flush() {
    return timerId === undefined ? result : trailingEdge(now());
  }

function debounced() {
    var time = now(),
        isInvoking = shouldInvoke(time);

lastArgs = arguments;
    lastThis = this;
    lastCallTime = time;

if (isInvoking) {
      if (timerId === undefined) {
        return leadingEdge(lastCallTime);
      }
      if (maxing) {
        // Handle invocations in a tight loop.
        timerId = setTimeout(timerExpired, wait);
        return invokeFunc(lastCallTime);
      }
    }
    if (timerId === undefined) {
      timerId = setTimeout(timerExpired, wait);
    }
    return result;
  }
  debounced.cancel = cancel;
  debounced.flush = flush;
  return debounced;
}

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */
function isObject(value) {
  var type = typeof value;
  return !!value && (type == 'object' || type == 'function');
}

/**
 * Converts `value` to a number.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to process.
 * @returns {number} Returns the number.
 * @example
 *
 * _.toNumber(3.2);
 * // => 3.2
 *
 * _.toNumber(Number.MIN_VALUE);
 * // => 5e-324
 *
 * _.toNumber(Infinity);
 * // => Infinity
 *
 * _.toNumber('3.2');
 * // => 3.2
 */
function toNumber(value) {
  if (typeof value == 'number') {
    return value;
  }
  if (isSymbol(value)) {
    return NAN;
  }
  if (isObject(value)) {
    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
    value = isObject(other) ? (other + '') : other;
  }
  if (typeof value != 'string') {
    return value === 0 ? value : +value;
  }
  value = value.replace(reTrim, '');
  var isBinary = reIsBinary.test(value);
  return (isBinary || reIsOctal.test(value))
    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
    : (reIsBadHex.test(value) ? NAN : +value);
}

module.exports = debounce;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 963 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global, module) {/**
 * Lodash (Custom Build) <https://lodash.com/>
 * Build: `lodash modularize exports="npm" -o ./`
 * Copyright JS Foundation and other contributors <https://js.foundation/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used to detect hot functions by number of calls within a span of milliseconds. */
var HOT_COUNT = 800,
    HOT_SPAN = 16;

/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    asyncTag = '[object AsyncFunction]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    nullTag = '[object Null]',
    objectTag = '[object Object]',
    proxyTag = '[object Proxy]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    undefinedTag = '[object Undefined]',
    weakMapTag = '[object WeakMap]';

/**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;

/** Used to identify `toStringTag` values of typed arrays. */
var typedArrayTags = {};
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
typedArrayTags[uint32Tag] = true;
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
typedArrayTags[setTag] = typedArrayTags[stringTag] =
typedArrayTags[weakMapTag] = false;

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

/** Detect free variable `exports`. */
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;

/** Detect free variable `process` from Node.js. */
var freeProcess = moduleExports && freeGlobal.process;

/** Used to access faster Node.js helpers. */
var nodeUtil = (function() {
  try {
    return freeProcess && freeProcess.binding && freeProcess.binding('util');
  } catch (e) {}
}());

/* Node.js helper references. */
var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

/**
 * A faster alternative to `Function#apply`, this function invokes `func`
 * with the `this` binding of `thisArg` and the arguments of `args`.
 *
 * @private
 * @param {Function} func The function to invoke.
 * @param {*} thisArg The `this` binding of `func`.
 * @param {Array} args The arguments to invoke `func` with.
 * @returns {*} Returns the result of `func`.
 */
function apply(func, thisArg, args) {
  switch (args.length) {
    case 0: return func.call(thisArg);
    case 1: return func.call(thisArg, args[0]);
    case 2: return func.call(thisArg, args[0], args[1]);
    case 3: return func.call(thisArg, args[0], args[1], args[2]);
  }
  return func.apply(thisArg, args);
}

/**
 * The base implementation of `_.times` without support for iteratee shorthands
 * or max array length checks.
 *
 * @private
 * @param {number} n The number of times to invoke `iteratee`.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the array of results.
 */
function baseTimes(n, iteratee) {
  var index = -1,
      result = Array(n);

while (++index < n) {
    result[index] = iteratee(index);
  }
  return result;
}

/**
 * Gets the value at `key` of `object`.
 *
 * @private
 * @param {Object} [object] The object to query.
 * @param {string} key The key of the property to get.
 * @returns {*} Returns the property value.
 */
function getValue(object, key) {
  return object == null ? undefined : object[key];
}

/**
 * Gets the value at `key`, unless `key` is "__proto__".
 *
 * @private
 * @param {Object} object The object to query.
 * @param {string} key The key of the property to get.
 * @returns {*} Returns the property value.
 */
function safeGet(object, key) {
  return key == '__proto__'
    ? undefined
    : object[key];
}

/** Used for built-in method references. */
var arrayProto = Array.prototype,
    funcProto = Function.prototype,
    objectProto = Object.prototype;

/** Used to detect overreaching core-js shims. */
var coreJsData = root['__core-js_shared__'];

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Used to detect methods masquerading as native. */
var maskSrcKey = (function() {
  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
  return uid ? ('Symbol(src)_1.' + uid) : '';
}());

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString = objectProto.toString;

/** Used to infer the `Object` constructor. */
var objectCtorString = funcToString.call(Object);

/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);

/** Built-in value references. */
var Buffer = moduleExports ? root.Buffer : undefined,
    Symbol = root.Symbol,
    Uint8Array = root.Uint8Array,
    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
    getPrototype = overArg(Object.getPrototypeOf, Object),
    objectCreate = Object.create,
    propertyIsEnumerable = objectProto.propertyIsEnumerable,
    splice = arrayProto.splice,
    symToStringTag = Symbol ? Symbol.toStringTag : undefined;

var defineProperty = (function() {
  try {
    var func = getNative(Object, 'defineProperty');
    func({}, '', {});
    return func;
  } catch (e) {}
}());

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
    nativeMax = Math.max,
    nativeNow = Date.now;

/* Built-in method references that are verified to be native. */
var Map = getNative(root, 'Map'),
    nativeCreate = getNative(Object, 'create');

/**
 * Creates a hash object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function Hash(entries) {
  var index = -1,
      length = entries == null ? 0 : entries.length;

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the hash.
 *
 * @private
 * @name clear
 * @memberOf Hash
 */
function hashClear() {
  this.__data__ = nativeCreate ? nativeCreate(null) : {};
  this.size = 0;
}

/**
 * Removes `key` and its value from the hash.
 *
 * @private
 * @name delete
 * @memberOf Hash
 * @param {Object} hash The hash to modify.
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function hashDelete(key) {
  var result = this.has(key) && delete this.__data__[key];
  this.size -= result ? 1 : 0;
  return result;
}

/**
 * Gets the hash value for `key`.
 *
 * @private
 * @name get
 * @memberOf Hash
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function hashGet(key) {
  var data = this.__data__;
  if (nativeCreate) {
    var result = data[key];
    return result === HASH_UNDEFINED ? undefined : result;
  }
  return hasOwnProperty.call(data, key) ? data[key] : undefined;
}

/**
 * Checks if a hash value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Hash
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function hashHas(key) {
  var data = this.__data__;
  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
}

/**
 * Sets the hash `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Hash
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the hash instance.
 */
function hashSet(key, value) {
  var data = this.__data__;
  this.size += this.has(key) ? 0 : 1;
  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
  return this;
}

// Add methods to `Hash`.
Hash.prototype.clear = hashClear;
Hash.prototype['delete'] = hashDelete;
Hash.prototype.get = hashGet;
Hash.prototype.has = hashHas;
Hash.prototype.set = hashSet;

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the list cache.
 *
 * @private
 * @name clear
 * @memberOf ListCache
 */
function listCacheClear() {
  this.__data__ = [];
  this.size = 0;
}

/**
 * Removes `key` and its value from the list cache.
 *
 * @private
 * @name delete
 * @memberOf ListCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function listCacheDelete(key) {
  var data = this.__data__,
      index = assocIndexOf(data, key);

if (index < 0) {
    return false;
  }
  var lastIndex = data.length - 1;
  if (index == lastIndex) {
    data.pop();
  } else {
    splice.call(data, index, 1);
  }
  --this.size;
  return true;
}

/**
 * Gets the list cache value for `key`.
 *
 * @private
 * @name get
 * @memberOf ListCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function listCacheGet(key) {
  var data = this.__data__,
      index = assocIndexOf(data, key);

return index < 0 ? undefined : data[index][1];
}

/**
 * Checks if a list cache value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf ListCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function listCacheHas(key) {
  return assocIndexOf(this.__data__, key) > -1;
}

/**
 * Sets the list cache `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf ListCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the list cache instance.
 */
function listCacheSet(key, value) {
  var data = this.__data__,
      index = assocIndexOf(data, key);

if (index < 0) {
    ++this.size;
    data.push([key, value]);
  } else {
    data[index][1] = value;
  }
  return this;
}

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the map.
 *
 * @private
 * @name clear
 * @memberOf MapCache
 */
function mapCacheClear() {
  this.size = 0;
  this.__data__ = {
    'hash': new Hash,
    'map': new (Map || ListCache),
    'string': new Hash
  };
}

/**
 * Removes `key` and its value from the map.
 *
 * @private
 * @name delete
 * @memberOf MapCache
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function mapCacheDelete(key) {
  var result = getMapData(this, key)['delete'](key);
  this.size -= result ? 1 : 0;
  return result;
}

/**
 * Gets the map value for `key`.
 *
 * @private
 * @name get
 * @memberOf MapCache
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function mapCacheGet(key) {
  return getMapData(this, key).get(key);
}

/**
 * Checks if a map value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf MapCache
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function mapCacheHas(key) {
  return getMapData(this, key).has(key);
}

/**
 * Sets the map `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf MapCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the map cache instance.
 */
function mapCacheSet(key, value) {
  var data = getMapData(this, key),
      size = data.size;

data.set(key, value);
  this.size += data.size == size ? 0 : 1;
  return this;
}

/**
 * Removes all key-value entries from the stack.
 *
 * @private
 * @name clear
 * @memberOf Stack
 */
function stackClear() {
  this.__data__ = new ListCache;
  this.size = 0;
}

/**
 * Removes `key` and its value from the stack.
 *
 * @private
 * @name delete
 * @memberOf Stack
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function stackDelete(key) {
  var data = this.__data__,
      result = data['delete'](key);

this.size = data.size;
  return result;
}

/**
 * Gets the stack value for `key`.
 *
 * @private
 * @name get
 * @memberOf Stack
 * @param {string} key The key of the value to get.
 * @returns {*} Returns the entry value.
 */
function stackGet(key) {
  return this.__data__.get(key);
}

/**
 * Checks if a stack value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Stack
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function stackHas(key) {
  return this.__data__.has(key);
}

/**
 * Sets the stack `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Stack
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the stack cache instance.
 */
function stackSet(key, value) {
  var data = this.__data__;
  if (data instanceof ListCache) {
    var pairs = data.__data__;
    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
      pairs.push([key, value]);
      this.size = ++data.size;
      return this;
    }
    data = this.__data__ = new MapCache(pairs);
  }
  data.set(key, value);
  this.size = data.size;
  return this;
}

// Add methods to `Stack`.
Stack.prototype.clear = stackClear;
Stack.prototype['delete'] = stackDelete;
Stack.prototype.get = stackGet;
Stack.prototype.has = stackHas;
Stack.prototype.set = stackSet;

/**
 * This function is like `assignValue` except that it doesn't assign
 * `undefined` values.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {string} key The key of the property to assign.
 * @param {*} value The value to assign.
 */
function assignMergeValue(object, key, value) {
  if ((value !== undefined && !eq(object[key], value)) ||
      (value === undefined && !(key in object))) {
    baseAssignValue(object, key, value);
  }
}

/**
 * The base implementation of `baseForOwn` which iterates over `object`
 * properties returned by `keysFunc` and invokes `iteratee` for each property.
 * Iteratee functions may exit iteration early by explicitly returning `false`.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @returns {Object} Returns `object`.
 */
var baseFor = createBaseFor();

/**
 * The base implementation of `_.isArguments`.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
 */
function baseIsArguments(value) {
  return isObjectLike(value) && baseGetTag(value) == argsTag;
}

/**
 * The base implementation of `_.isNative` without bad shim checks.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function,
 *  else `false`.
 */
function baseIsNative(value) {
  if (!isObject(value) || isMasked(value)) {
    return false;
  }
  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
  return pattern.test(toSource(value));
}

/**
 * The base implementation of `_.isTypedArray` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
 */
function baseIsTypedArray(value) {
  return isObjectLike(value) &&
    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
}

/**
 * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */
function baseKeysIn(object) {
  if (!isObject(object)) {
    return nativeKeysIn(object);
  }
  var isProto = isPrototype(object),
      result = [];

for (var key in object) {
    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
      result.push(key);
    }
  }
  return result;
}

/**
 * The base implementation of `_.merge` without support for multiple sources.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @param {number} srcIndex The index of `source`.
 * @param {Function} [customizer] The function to customize merged values.
 * @param {Object} [stack] Tracks traversed source values and their merged
 *  counterparts.
 */
function baseMerge(object, source, srcIndex, customizer, stack) {
  if (object === source) {
    return;
  }
  baseFor(source, function(srcValue, key) {
    if (isObject(srcValue)) {
      stack || (stack = new Stack);
      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
    }
    else {
      var newValue = customizer
        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
        : undefined;

if (newValue === undefined) {
        newValue = srcValue;
      }
      assignMergeValue(object, key, newValue);
    }
  }, keysIn);
}

/**
 * A specialized version of `baseMerge` for arrays and objects which performs
 * deep merges and tracks traversed objects enabling objects with circular
 * references to be merged.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @param {string} key The key of the value to merge.
 * @param {number} srcIndex The index of `source`.
 * @param {Function} mergeFunc The function to merge values.
 * @param {Function} [customizer] The function to customize assigned values.
 * @param {Object} [stack] Tracks traversed source values and their merged
 *  counterparts.
 */
function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
  var objValue = safeGet(object, key),
      srcValue = safeGet(source, key),
      stacked = stack.get(srcValue);

if (stacked) {
    assignMergeValue(object, key, stacked);
    return;
  }
  var newValue = customizer
    ? customizer(objValue, srcValue, (key + ''), object, source, stack)
    : undefined;

var isCommon = newValue === undefined;

if (isCommon) {
    var isArr = isArray(srcValue),
        isBuff = !isArr && isBuffer(srcValue),
        isTyped = !isArr && !isBuff && isTypedArray(srcValue);

newValue = srcValue;
    if (isArr || isBuff || isTyped) {
      if (isArray(objValue)) {
        newValue = objValue;
      }
      else if (isArrayLikeObject(objValue)) {
        newValue = copyArray(objValue);
      }
      else if (isBuff) {
        isCommon = false;
        newValue = cloneBuffer(srcValue, true);
      }
      else if (isTyped) {
        isCommon = false;
        newValue = cloneTypedArray(srcValue, true);
      }
      else {
        newValue = [];
      }
    }
    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
      newValue = objValue;
      if (isArguments(objValue)) {
        newValue = toPlainObject(objValue);
      }
      else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
        newValue = initCloneObject(srcValue);
      }
    }
    else {
      isCommon = false;
    }
  }
  if (isCommon) {
    // Recursively merge objects and arrays (susceptible to call stack limits).
    stack.set(srcValue, newValue);
    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
    stack['delete'](srcValue);
  }
  assignMergeValue(object, key, newValue);
}

/**
 * The base implementation of `setToString` without support for hot loop shorting.
 *
 * @private
 * @param {Function} func The function to modify.
 * @param {Function} string The `toString` result.
 * @returns {Function} Returns `func`.
 */
var baseSetToString = !defineProperty ? identity : function(func, string) {
  return defineProperty(func, 'toString', {
    'configurable': true,
    'enumerable': false,
    'value': constant(string),
    'writable': true
  });
};

/**
 * Creates a clone of  `buffer`.
 *
 * @private
 * @param {Buffer} buffer The buffer to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Buffer} Returns the cloned buffer.
 */
function cloneBuffer(buffer, isDeep) {
  if (isDeep) {
    return buffer.slice();
  }
  var length = buffer.length,
      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

buffer.copy(result);
  return result;
}

/**
 * Creates a clone of `typedArray`.
 *
 * @private
 * @param {Object} typedArray The typed array to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Object} Returns the cloned typed array.
 */
function cloneTypedArray(typedArray, isDeep) {
  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
}

array || (array = Array(length));
  while (++index < length) {
    array[index] = source[index];
  }
  return array;
}

var index = -1,
      length = props.length;

while (++index < length) {
    var key = props[index];

var newValue = customizer
      ? customizer(object[key], source[key], key, object, source)
      : undefined;

/**
 * Creates a function like `_.assign`.
 *
 * @private
 * @param {Function} assigner The function to assign values.
 * @returns {Function} Returns the new assigner function.
 */
function createAssigner(assigner) {
  return baseRest(function(object, sources) {
    var index = -1,
        length = sources.length,
        customizer = length > 1 ? sources[length - 1] : undefined,
        guard = length > 2 ? sources[2] : undefined;

customizer = (assigner.length > 3 && typeof customizer == 'function')
      ? (length--, customizer)
      : undefined;

if (guard && isIterateeCall(sources[0], sources[1], guard)) {
      customizer = length < 3 ? undefined : customizer;
      length = 1;
    }
    object = Object(object);
    while (++index < length) {
      var source = sources[index];
      if (source) {
        assigner(object, source, index, customizer);
      }
    }
    return object;
  });
}

/**
 * Creates a base function for methods like `_.forIn` and `_.forOwn`.
 *
 * @private
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {Function} Returns the new base function.
 */
function createBaseFor(fromRight) {
  return function(object, iteratee, keysFunc) {
    var index = -1,
        iterable = Object(object),
        props = keysFunc(object),
        length = props.length;

while (length--) {
      var key = props[fromRight ? length : ++index];
      if (iteratee(iterable[key], key, iterable) === false) {
        break;
      }
    }
    return object;
  };
}

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */
function getRawTag(value) {
  var isOwn = hasOwnProperty.call(value, symToStringTag),
      tag = value[symToStringTag];

try {
    value[symToStringTag] = undefined;
    var unmasked = true;
  } catch (e) {}

var result = nativeObjectToString.call(value);
  if (unmasked) {
    if (isOwn) {
      value[symToStringTag] = tag;
    } else {
      delete value[symToStringTag];
    }
  }
  return result;
}

/**
 * Initializes an object clone.
 *
 * @private
 * @param {Object} object The object to clone.
 * @returns {Object} Returns the initialized clone.
 */
function initCloneObject(object) {
  return (typeof object.constructor == 'function' && !isPrototype(object))
    ? baseCreate(getPrototype(object))
    : {};
}

return !!length &&
    (type == 'number' ||
      (type != 'symbol' && reIsUint.test(value))) &&
        (value > -1 && value % 1 == 0 && value < length);
}

/**
 * Checks if `value` is suitable for use as unique object key.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
 */
function isKeyable(value) {
  var type = typeof value;
  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
    ? (value !== '__proto__')
    : (value === null);
}

/**
 * Checks if `func` has its source masked.
 *
 * @private
 * @param {Function} func The function to check.
 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
 */
function isMasked(func) {
  return !!maskSrcKey && (maskSrcKey in func);
}

return value === proto;
}

/**
 * This function is like
 * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
 * except that it includes inherited enumerable properties.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */
function nativeKeysIn(object) {
  var result = [];
  if (object != null) {
    for (var key in Object(object)) {
      result.push(key);
    }
  }
  return result;
}

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */
function objectToString(value) {
  return nativeObjectToString.call(value);
}

/**
 * Creates a function that'll short out and invoke `identity` instead
 * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
 * milliseconds.
 *
 * @private
 * @param {Function} func The function to restrict.
 * @returns {Function} Returns the new shortable function.
 */
function shortOut(func) {
  var count = 0,
      lastCalled = 0;

return function() {
    var stamp = nativeNow(),
        remaining = HOT_SPAN - (stamp - lastCalled);

lastCalled = stamp;
    if (remaining > 0) {
      if (++count >= HOT_COUNT) {
        return arguments[0];
      }
    } else {
      count = 0;
    }
    return func.apply(undefined, arguments);
  };
}

/**
 * Converts `value` to a plain object flattening inherited enumerable string
 * keyed properties of `value` to own properties of the plain object.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category Lang
 * @param {*} value The value to convert.
 * @returns {Object} Returns the converted plain object.
 * @example
 *
 * function Foo() {
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.assign({ 'a': 1 }, new Foo);
 * // => { 'a': 1, 'b': 2 }
 *
 * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
 * // => { 'a': 1, 'b': 2, 'c': 3 }
 */
function toPlainObject(value) {
  return copyObject(value, keysIn(value));
}

/**
 * This method is like `_.merge` except that it accepts `customizer` which
 * is invoked to produce the merged values of the destination and source
 * properties. If `customizer` returns `undefined`, merging is handled by the
 * method instead. The `customizer` is invoked with six arguments:
 * (objValue, srcValue, key, object, source, stack).
 *
 * **Note:** This method mutates `object`.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Object
 * @param {Object} object The destination object.
 * @param {...Object} sources The source objects.
 * @param {Function} customizer The function to customize assigned values.
 * @returns {Object} Returns `object`.
 * @example
 *
 * function customizer(objValue, srcValue) {
 *   if (_.isArray(objValue)) {
 *     return objValue.concat(srcValue);
 *   }
 * }
 *
 * var object = { 'a': [1], 'b': [2] };
 * var other = { 'a': [3], 'b': [4] };
 *
 * _.mergeWith(object, other, customizer);
 * // => { 'a': [1, 3], 'b': [2, 4] }
 */
var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
  baseMerge(object, source, srcIndex, customizer);
});

/**
 * Creates a function that returns `value`.
 *
 * @static
 * @memberOf _
 * @since 2.4.0
 * @category Util
 * @param {*} value The value to return from the new function.
 * @returns {Function} Returns the new constant function.
 * @example
 *
 * var objects = _.times(2, _.constant({ 'a': 1 }));
 *
 * console.log(objects);
 * // => [{ 'a': 1 }, { 'a': 1 }]
 *
 * console.log(objects[0] === objects[1]);
 * // => true
 */
function constant(value) {
  return function() {
    return value;
  };
}

/**
 * This method returns `false`.
 *
 * @static
 * @memberOf _
 * @since 4.13.0
 * @category Util
 * @returns {boolean} Returns `false`.
 * @example
 *
 * _.times(2, _.stubFalse);
 * // => [false, false]
 */
function stubFalse() {
  return false;
}

module.exports = mergeWith;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29), __webpack_require__(201)(module)))

/***/ }),
/* 964 */
/***/ (function(module, exports, __webpack_require__) {

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0,
    MAX_SAFE_INTEGER = 9007199254740991;

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    funcTag = '[object Function]',
    genTag = '[object GeneratorFunction]',
    symbolTag = '[object Symbol]';

/**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

/**
 * A specialized version of `_.includes` for arrays without support for
 * specifying an index to search from.
 *
 * @private
 * @param {Array} [array] The array to inspect.
 * @param {*} target The value to search for.
 * @returns {boolean} Returns `true` if `target` is found, else `false`.
 */
function arrayIncludes(array, value) {
  var length = array ? array.length : 0;
  return !!length && baseIndexOf(array, value, 0) > -1;
}

while (++index < length) {
    if (comparator(value, array[index])) {
      return true;
    }
  }
  return false;
}

while (++index < length) {
    result[index] = iteratee(array[index], index, array);
  }
  return result;
}

while (++index < length) {
    array[offset + index] = values[index];
  }
  return array;
}

/**
 * The base implementation of `_.findIndex` and `_.findLastIndex` without
 * support for iteratee shorthands.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {Function} predicate The function invoked per iteration.
 * @param {number} fromIndex The index to search from.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseFindIndex(array, predicate, fromIndex, fromRight) {
  var length = array.length,
      index = fromIndex + (fromRight ? 1 : -1);

while ((fromRight ? index-- : ++index < length)) {
    if (predicate(array[index], index, array)) {
      return index;
    }
  }
  return -1;
}

/**
 * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseIndexOf(array, value, fromIndex) {
  if (value !== value) {
    return baseFindIndex(array, baseIsNaN, fromIndex);
  }
  var index = fromIndex - 1,
      length = array.length;

while (++index < length) {
    if (array[index] === value) {
      return index;
    }
  }
  return -1;
}

/**
 * The base implementation of `_.isNaN` without support for number objects.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
 */
function baseIsNaN(value) {
  return value !== value;
}

while (++index < n) {
    result[index] = iteratee(index);
  }
  return result;
}

/**
 * Checks if a cache value for `key` exists.
 *
 * @private
 * @param {Object} cache The cache to query.
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function cacheHas(cache, key) {
  return cache.has(key);
}

/**
 * Checks if `value` is a host object in IE < 9.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
 */
function isHostObject(value) {
  // Many host objects are `Object` objects that can coerce to strings
  // despite having improperly defined `toString` methods.
  var result = false;
  if (value != null && typeof value.toString != 'function') {
    try {
      result = !!(value + '');
    } catch (e) {}
  }
  return result;
}

/** Used for built-in method references. */
var arrayProto = Array.prototype,
    funcProto = Function.prototype,
    objectProto = Object.prototype;

/** Used to detect overreaching core-js shims. */
var coreJsData = root['__core-js_shared__'];

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var objectToString = objectProto.toString;

/** Built-in value references. */
var Symbol = root.Symbol,
    getPrototype = overArg(Object.getPrototypeOf, Object),
    propertyIsEnumerable = objectProto.propertyIsEnumerable,
    splice = arrayProto.splice,
    spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeGetSymbols = Object.getOwnPropertySymbols,
    nativeMax = Math.max;

/* Built-in method references that are verified to be native. */
var Map = getNative(root, 'Map'),
    nativeCreate = getNative(Object, 'create');

/**
 * Creates a hash object.
 *
 * @private
 * @constructor
 * @param {Array} [entries] The key-value pairs to cache.
 */
function Hash(entries) {
  var index = -1,
      length = entries ? entries.length : 0;

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the hash.
 *
 * @private
 * @name clear
 * @memberOf Hash
 */
function hashClear() {
  this.__data__ = nativeCreate ? nativeCreate(null) : {};
}

/**
 * Removes `key` and its value from the hash.
 *
 * @private
 * @name delete
 * @memberOf Hash
 * @param {Object} hash The hash to modify.
 * @param {string} key The key of the value to remove.
 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
 */
function hashDelete(key) {
  return this.has(key) && delete this.__data__[key];
}

/**
 * Checks if a hash value for `key` exists.
 *
 * @private
 * @name has
 * @memberOf Hash
 * @param {string} key The key of the entry to check.
 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
 */
function hashHas(key) {
  var data = this.__data__;
  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
}

/**
 * Sets the hash `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf Hash
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the hash instance.
 */
function hashSet(key, value) {
  var data = this.__data__;
  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
  return this;
}

// Add methods to `Hash`.
Hash.prototype.clear = hashClear;
Hash.prototype['delete'] = hashDelete;
Hash.prototype.get = hashGet;
Hash.prototype.has = hashHas;
Hash.prototype.set = hashSet;

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the list cache.
 *
 * @private
 * @name clear
 * @memberOf ListCache
 */
function listCacheClear() {
  this.__data__ = [];
}

if (index < 0) {
    return false;
  }
  var lastIndex = data.length - 1;
  if (index == lastIndex) {
    data.pop();
  } else {
    splice.call(data, index, 1);
  }
  return true;
}

return index < 0 ? undefined : data[index][1];
}

if (index < 0) {
    data.push([key, value]);
  } else {
    data[index][1] = value;
  }
  return this;
}

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

/**
 * Removes all key-value entries from the map.
 *
 * @private
 * @name clear
 * @memberOf MapCache
 */
function mapCacheClear() {
  this.__data__ = {
    'hash': new Hash,
    'map': new (Map || ListCache),
    'string': new Hash
  };
}

/**
 * Sets the map `key` to `value`.
 *
 * @private
 * @name set
 * @memberOf MapCache
 * @param {string} key The key of the value to set.
 * @param {*} value The value to set.
 * @returns {Object} Returns the map cache instance.
 */
function mapCacheSet(key, value) {
  getMapData(this, key).set(key, value);
  return this;
}

this.__data__ = new MapCache;
  while (++index < length) {
    this.add(values[index]);
  }
}

/**
 * Adds `value` to the array cache.
 *
 * @private
 * @name add
 * @memberOf SetCache
 * @alias push
 * @param {*} value The value to cache.
 * @returns {Object} Returns the cache instance.
 */
function setCacheAdd(value) {
  this.__data__.set(value, HASH_UNDEFINED);
  return this;
}

/**
 * Checks if `value` is in the array cache.
 *
 * @private
 * @name has
 * @memberOf SetCache
 * @param {*} value The value to search for.
 * @returns {number} Returns `true` if `value` is found, else `false`.
 */
function setCacheHas(value) {
  return this.__data__.has(value);
}

// Add methods to `SetCache`.
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
SetCache.prototype.has = setCacheHas;

/**
 * Creates an array of the enumerable property names of the array-like `value`.
 *
 * @private
 * @param {*} value The value to query.
 * @param {boolean} inherited Specify returning inherited property names.
 * @returns {Array} Returns the array of property names.
 */
function arrayLikeKeys(value, inherited) {
  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
  // Safari 9 makes `arguments.length` enumerable in strict mode.
  var result = (isArray(value) || isArguments(value))
    ? baseTimes(value.length, String)
    : [];

var length = result.length,
      skipIndexes = !!length;

for (var key in value) {
    if ((inherited || hasOwnProperty.call(value, key)) &&
        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
      result.push(key);
    }
  }
  return result;
}

predicate || (predicate = isFlattenable);
  result || (result = []);

/**
 * The base implementation of `_.isNative` without bad shim checks.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function,
 *  else `false`.
 */
function baseIsNative(value) {
  if (!isObject(value) || isMasked(value)) {
    return false;
  }
  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
  return pattern.test(toSource(value));
}

for (var key in object) {
    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
      result.push(key);
    }
  }
  return result;
}

/**
 * The base implementation of `_.pick` without support for individual
 * property identifiers.
 *
 * @private
 * @param {Object} object The source object.
 * @param {string[]} props The property identifiers to pick.
 * @returns {Object} Returns the new object.
 */
function basePick(object, props) {
  object = Object(object);
  return basePickBy(object, props, function(value, key) {
    return key in object;
  });
}

/**
 * The base implementation of  `_.pickBy` without support for iteratee shorthands.
 *
 * @private
 * @param {Object} object The source object.
 * @param {string[]} props The property identifiers to pick from.
 * @param {Function} predicate The function invoked per property.
 * @returns {Object} Returns the new object.
 */
function basePickBy(object, props, predicate) {
  var index = -1,
      length = props.length,
      result = {};

while (++index < length) {
    var key = props[index],
        value = object[key];

if (predicate(value, key)) {
      result[key] = value;
    }
  }
  return result;
}

/**
 * The base implementation of `_.rest` which doesn't validate or coerce arguments.
 *
 * @private
 * @param {Function} func The function to apply a rest parameter to.
 * @param {number} [start=func.length-1] The start position of the rest parameter.
 * @returns {Function} Returns the new function.
 */
function baseRest(func, start) {
  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
  return function() {
    var args = arguments,
        index = -1,
        length = nativeMax(args.length - start, 0),
        array = Array(length);

while (++index < length) {
      array[index] = args[start + index];
    }
    index = -1;
    var otherArgs = Array(start + 1);
    while (++index < start) {
      otherArgs[index] = args[index];
    }
    otherArgs[start] = array;
    return apply(func, this, otherArgs);
  };
}

/**
 * Creates an array of the own enumerable symbol properties of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of symbols.
 */
var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;

/**
 * Creates an array of the own and inherited enumerable symbol properties
 * of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of symbols.
 */
var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
  var result = [];
  while (object) {
    arrayPush(result, getSymbols(object));
    object = getPrototype(object);
  }
  return result;
};

/**
 * Checks if `value` is a flattenable `arguments` object or array.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
 */
function isFlattenable(value) {
  return isArray(value) || isArguments(value) ||
    !!(spreadableSymbol && value && value[spreadableSymbol]);
}

/**
 * Checks if `value` is a valid array-like index.
 *
 * @private
 * @param {*} value The value to check.
 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
 */
function isIndex(value, length) {
  length = length == null ? MAX_SAFE_INTEGER : length;
  return !!length &&
    (typeof value == 'number' || reIsUint.test(value)) &&
    (value > -1 && value % 1 == 0 && value < length);
}

return value === proto;
}

/**
 * Converts `func` to its source code.
 *
 * @private
 * @param {Function} func The function to process.
 * @returns {string} Returns the source code.
 */
function toSource(func) {
  if (func != null) {
    try {
      return funcToString.call(func);
    } catch (e) {}
    try {
      return (func + '');
    } catch (e) {}
  }
  return '';
}

/**
 * Checks if `value` is likely an `arguments` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
 *  else `false`.
 * @example
 *
 * _.isArguments(function() { return arguments; }());
 * // => true
 *
 * _.isArguments([1, 2, 3]);
 * // => false
 */
function isArguments(value) {
  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
}

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */
function isFunction(value) {
  // The use of `Object#toString` avoids issues with the `typeof` operator
  // in Safari 8-9 which returns 'object' for typed array and other constructors.
  var tag = isObject(value) ? objectToString.call(value) : '';
  return tag == funcTag || tag == genTag;
}

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */
function isObject(value) {
  var type = typeof value;
  return !!value && (type == 'object' || type == 'function');
}

/**
 * The opposite of `_.pick`; this method creates an object composed of the
 * own and inherited enumerable string keyed properties of `object` that are
 * not omitted.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Object
 * @param {Object} object The source object.
 * @param {...(string|string[])} [props] The property identifiers to omit.
 * @returns {Object} Returns the new object.
 * @example
 *
 * var object = { 'a': 1, 'b': '2', 'c': 3 };
 *
 * _.omit(object, ['a', 'c']);
 * // => { 'b': '2' }
 */
var omit = baseRest(function(object, props) {
  if (object == null) {
    return {};
  }
  props = arrayMap(baseFlatten(props, 1), toKey);
  return basePick(object, baseDifference(getAllKeysIn(object), props));
});

module.exports = omit;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 965 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(85),
    root = __webpack_require__(45);

/* Built-in method references that are verified to be native. */
var DataView = getNative(root, 'DataView');

module.exports = DataView;

/***/ }),
/* 966 */
/***/ (function(module, exports, __webpack_require__) {

var hashClear = __webpack_require__(1028),
    hashDelete = __webpack_require__(1029),
    hashGet = __webpack_require__(1030),
    hashHas = __webpack_require__(1031),
    hashSet = __webpack_require__(1032);

this.clear();
  while (++index < length) {
    var entry = entries[index];
    this.set(entry[0], entry[1]);
  }
}

// Add methods to `Hash`.
Hash.prototype.clear = hashClear;
Hash.prototype['delete'] = hashDelete;
Hash.prototype.get = hashGet;
Hash.prototype.has = hashHas;
Hash.prototype.set = hashSet;

module.exports = Hash;

/***/ }),
/* 967 */
/***/ (function(module, exports, __webpack_require__) {

var getNative = __webpack_require__(85),
    root = __webpack_require__(45);

/* Built-in method references that are verified to be native. */
var Promise = getNative(root, 'Promise');

module.exports = Promise;

/***/ }),
/* 968 */
/***/ (function(module, exports) {

module.exports = apply;

/***/ }),
/* 969 */
/***/ (function(module, exports) {

/**
 * A specialized version of `_.reduce` for arrays without support for
 * iteratee shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {*} [accumulator] The initial value.
 * @param {boolean} [initAccum] Specify using the first element of `array` as
 *  the initial value.
 * @returns {*} Returns the accumulated value.
 */
function arrayReduce(array, iteratee, accumulator, initAccum) {
  var index = -1,
      length = array == null ? 0 : array.length;

if (initAccum && length) {
    accumulator = array[++index];
  }
  while (++index < length) {
    accumulator = iteratee(accumulator, array[index], index, array);
  }
  return accumulator;
}

module.exports = arrayReduce;

/***/ }),
/* 970 */
/***/ (function(module, exports) {

/**
 * A specialized version of `_.some` for arrays without support for iteratee
 * shorthands.
 *
 * @private
 * @param {Array} [array] The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {boolean} Returns `true` if any element passes the predicate check,
 *  else `false`.
 */
function arraySome(array, predicate) {
  var index = -1,
      length = array == null ? 0 : array.length;

while (++index < length) {
    if (predicate(array[index], index, array)) {
      return true;
    }
  }
  return false;
}

module.exports = arraySome;

/***/ }),
/* 971 */
/***/ (function(module, exports) {

/**
 * Converts an ASCII `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function asciiToArray(string) {
  return string.split('');
}

module.exports = asciiToArray;

/***/ }),
/* 972 */
/***/ (function(module, exports) {

/** Used to match words composed of alphanumeric characters. */
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

/**
 * Splits an ASCII `string` into an array of its words.
 *
 * @private
 * @param {string} The string to inspect.
 * @returns {Array} Returns the words of `string`.
 */
function asciiWords(string) {
  return string.match(reAsciiWord) || [];
}

module.exports = asciiWords;

/***/ }),
/* 973 */
/***/ (function(module, exports, __webpack_require__) {

var copyObject = __webpack_require__(109),
    keys = __webpack_require__(110);

/**
 * The base implementation of `_.assign` without support for multiple sources
 * or `customizer` functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @returns {Object} Returns `object`.
 */
function baseAssign(object, source) {
  return object && copyObject(source, keys(source), object);
}

module.exports = baseAssign;

/***/ }),
/* 974 */
/***/ (function(module, exports, __webpack_require__) {

var copyObject = __webpack_require__(109),
    keysIn = __webpack_require__(184);

/**
 * The base implementation of `_.assignIn` without support for multiple sources
 * or `customizer` functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @returns {Object} Returns `object`.
 */
function baseAssignIn(object, source) {
  return object && copyObject(source, keysIn(source), object);
}

module.exports = baseAssignIn;

/***/ }),
/* 975 */
/***/ (function(module, exports) {

while ((fromRight ? index-- : ++index < length)) {
    if (predicate(array[index], index, array)) {
      return index;
    }
  }
  return -1;
}

module.exports = baseFindIndex;

/***/ }),
/* 976 */
/***/ (function(module, exports, __webpack_require__) {

var createBaseFor = __webpack_require__(1014);

module.exports = baseFor;

/***/ }),
/* 977 */
/***/ (function(module, exports) {

/**
 * The base implementation of `_.hasIn` without support for deep paths.
 *
 * @private
 * @param {Object} [object] The object to query.
 * @param {Array|string} key The key to check.
 * @returns {boolean} Returns `true` if `key` exists, else `false`.
 */
function baseHasIn(object, key) {
  return object != null && key in Object(object);
}

module.exports = baseHasIn;

/***/ }),
/* 978 */
/***/ (function(module, exports, __webpack_require__) {

var baseFindIndex = __webpack_require__(975),
    baseIsNaN = __webpack_require__(984),
    strictIndexOf = __webpack_require__(1066);

/**
 * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function baseIndexOf(array, value, fromIndex) {
  return value === value
    ? strictIndexOf(array, value, fromIndex)
    : baseFindIndex(array, baseIsNaN, fromIndex);
}

module.exports = baseIndexOf;

/***/ }),
/* 979 */
/***/ (function(module, exports, __webpack_require__) {

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeMin = Math.min;

/**
 * The base implementation of methods like `_.intersection`, without support
 * for iteratee shorthands, that accepts an array of arrays to inspect.
 *
 * @private
 * @param {Array} arrays The arrays to inspect.
 * @param {Function} [iteratee] The iteratee invoked per element.
 * @param {Function} [comparator] The comparator invoked per element.
 * @returns {Array} Returns the new array of shared values.
 */
function baseIntersection(arrays, iteratee, comparator) {
  var includes = comparator ? arrayIncludesWith : arrayIncludes,
      length = arrays[0].length,
      othLength = arrays.length,
      othIndex = othLength,
      caches = Array(othLength),
      maxLength = Infinity,
      result = [];

while (othIndex--) {
    var array = arrays[othIndex];
    if (othIndex && iteratee) {
      array = arrayMap(array, baseUnary(iteratee));
    }
    maxLength = nativeMin(array.length, maxLength);
    caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
      ? new SetCache(othIndex && array)
      : undefined;
  }
  array = arrays[0];

var index = -1,
      seen = caches[0];

outer:
  while (++index < length && result.length < maxLength) {
    var value = array[index],
        computed = iteratee ? iteratee(value) : value;

value = (comparator || value !== 0) ? value : 0;
    if (!(seen
          ? cacheHas(seen, computed)
          : includes(result, computed, comparator)
        )) {
      othIndex = othLength;
      while (--othIndex) {
        var cache = caches[othIndex];
        if (!(cache
              ? cacheHas(cache, computed)
              : includes(arrays[othIndex], computed, comparator))
            ) {
          continue outer;
        }
      }
      if (seen) {
        seen.push(computed);
      }
      result.push(value);
    }
  }
  return result;
}

module.exports = baseIntersection;

/***/ }),
/* 980 */
/***/ (function(module, exports, __webpack_require__) {

var baseGetTag = __webpack_require__(84),
    isObjectLike = __webpack_require__(47);

/** `Object#toString` result references. */
var argsTag = '[object Arguments]';

module.exports = baseIsArguments;

/***/ }),
/* 981 */
/***/ (function(module, exports, __webpack_require__) {

var Stack = __webpack_require__(274),
    equalArrays = __webpack_require__(438),
    equalByTag = __webpack_require__(1021),
    equalObjects = __webpack_require__(1022),
    getTag = __webpack_require__(133),
    isArray = __webpack_require__(27),
    isBuffer = __webpack_require__(181),
    isTypedArray = __webpack_require__(294);

/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1;

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    objectTag = '[object Object]';

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * A specialized version of `baseIsEqual` for arrays and objects which performs
 * deep comparisons and tracks traversed objects enabling objects with circular
 * references to be compared.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} [stack] Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
  var objIsArr = isArray(object),
      othIsArr = isArray(other),
      objTag = objIsArr ? arrayTag : getTag(object),
      othTag = othIsArr ? arrayTag : getTag(other);

objTag = objTag == argsTag ? objectTag : objTag;
  othTag = othTag == argsTag ? objectTag : othTag;

var objIsObj = objTag == objectTag,
      othIsObj = othTag == objectTag,
      isSameTag = objTag == othTag;

if (isSameTag && isBuffer(object)) {
    if (!isBuffer(other)) {
      return false;
    }
    objIsArr = true;
    objIsObj = false;
  }
  if (isSameTag && !objIsObj) {
    stack || (stack = new Stack);
    return (objIsArr || isTypedArray(object))
      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
  }
  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

if (objIsWrapped || othIsWrapped) {
      var objUnwrapped = objIsWrapped ? object.value() : object,
          othUnwrapped = othIsWrapped ? other.value() : other;

stack || (stack = new Stack);
      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
    }
  }
  if (!isSameTag) {
    return false;
  }
  stack || (stack = new Stack);
  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
}

module.exports = baseIsEqualDeep;

/***/ }),
/* 982 */
/***/ (function(module, exports, __webpack_require__) {

var getTag = __webpack_require__(133),
    isObjectLike = __webpack_require__(47);

/** `Object#toString` result references. */
var mapTag = '[object Map]';

/**
 * The base implementation of `_.isMap` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a map, else `false`.
 */
function baseIsMap(value) {
  return isObjectLike(value) && getTag(value) == mapTag;
}

module.exports = baseIsMap;

/***/ }),
/* 983 */
/***/ (function(module, exports, __webpack_require__) {

var Stack = __webpack_require__(274),
    baseIsEqual = __webpack_require__(282);

/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1,
    COMPARE_UNORDERED_FLAG = 2;

/**
 * The base implementation of `_.isMatch` without support for iteratee shorthands.
 *
 * @private
 * @param {Object} object The object to inspect.
 * @param {Object} source The object of property values to match.
 * @param {Array} matchData The property names, values, and compare flags to match.
 * @param {Function} [customizer] The function to customize comparisons.
 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
 */
function baseIsMatch(object, source, matchData, customizer) {
  var index = matchData.length,
      length = index,
      noCustomizer = !customizer;

if (object == null) {
    return !length;
  }
  object = Object(object);
  while (index--) {
    var data = matchData[index];
    if ((noCustomizer && data[2])
          ? data[1] !== object[data[0]]
          : !(data[0] in object)
        ) {
      return false;
    }
  }
  while (++index < length) {
    data = matchData[index];
    var key = data[0],
        objValue = object[key],
        srcValue = data[1];

if (noCustomizer && data[2]) {
      if (objValue === undefined && !(key in object)) {
        return false;
      }
    } else {
      var stack = new Stack;
      if (customizer) {
        var result = customizer(objValue, srcValue, key, object, source, stack);
      }
      if (!(result === undefined
            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
            : result
          )) {
        return false;
      }
    }
  }
  return true;
}

module.exports = baseIsMatch;

/***/ }),
/* 984 */
/***/ (function(module, exports) {

module.exports = baseIsNaN;

/***/ }),
/* 985 */
/***/ (function(module, exports, __webpack_require__) {

var isFunction = __webpack_require__(454),
    isMasked = __webpack_require__(1039),
    isObject = __webpack_require__(46),
    toSource = __webpack_require__(453);

/**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used for built-in method references. */
var funcProto = Function.prototype,
    objectProto = Object.prototype;

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

module.exports = baseIsNative;

/***/ }),
/* 986 */
/***/ (function(module, exports, __webpack_require__) {

var getTag = __webpack_require__(133),
    isObjectLike = __webpack_require__(47);

/** `Object#toString` result references. */
var setTag = '[object Set]';

/**
 * The base implementation of `_.isSet` without Node.js optimizations.
 *
 * @private
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a set, else `false`.
 */
function baseIsSet(value) {
  return isObjectLike(value) && getTag(value) == setTag;
}

module.exports = baseIsSet;

/***/ }),
/* 987 */
/***/ (function(module, exports, __webpack_require__) {

var baseGetTag = __webpack_require__(84),
    isLength = __webpack_require__(293),
    isObjectLike = __webpack_require__(47);

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    objectTag = '[object Object]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    weakMapTag = '[object WeakMap]';

module.exports = baseIsTypedArray;

/***/ }),
/* 988 */
/***/ (function(module, exports, __webpack_require__) {

var baseMatches = __webpack_require__(991),
    baseMatchesProperty = __webpack_require__(992),
    identity = __webpack_require__(178),
    isArray = __webpack_require__(27),
    property = __webpack_require__(1092);

/**
 * The base implementation of `_.iteratee`.
 *
 * @private
 * @param {*} [value=_.identity] The value to convert to an iteratee.
 * @returns {Function} Returns the iteratee.
 */
function baseIteratee(value) {
  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
  if (typeof value == 'function') {
    return value;
  }
  if (value == null) {
    return identity;
  }
  if (typeof value == 'object') {
    return isArray(value)
      ? baseMatchesProperty(value[0], value[1])
      : baseMatches(value);
  }
  return property(value);
}

module.exports = baseIteratee;

/***/ }),
/* 989 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(46),
    isPrototype = __webpack_require__(134),
    nativeKeysIn = __webpack_require__(1054);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

for (var key in object) {
    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
      result.push(key);
    }
  }
  return result;
}

module.exports = baseKeysIn;

/***/ }),
/* 990 */
/***/ (function(module, exports, __webpack_require__) {

var baseEach = __webpack_require__(429),
    isArrayLike = __webpack_require__(73);

/**
 * The base implementation of `_.map` without support for iteratee shorthands.
 *
 * @private
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns the new mapped array.
 */
function baseMap(collection, iteratee) {
  var index = -1,
      result = isArrayLike(collection) ? Array(collection.length) : [];

baseEach(collection, function(value, key, collection) {
    result[++index] = iteratee(value, key, collection);
  });
  return result;
}

module.exports = baseMap;

/***/ }),
/* 991 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsMatch = __webpack_require__(983),
    getMatchData = __webpack_require__(1023),
    matchesStrictComparable = __webpack_require__(449);

/**
 * The base implementation of `_.matches` which doesn't clone `source`.
 *
 * @private
 * @param {Object} source The object of property values to match.
 * @returns {Function} Returns the new spec function.
 */
function baseMatches(source) {
  var matchData = getMatchData(source);
  if (matchData.length == 1 && matchData[0][2]) {
    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
  }
  return function(object) {
    return object === source || baseIsMatch(object, source, matchData);
  };
}

module.exports = baseMatches;

/***/ }),
/* 992 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsEqual = __webpack_require__(282),
    get = __webpack_require__(1083),
    hasIn = __webpack_require__(1084),
    isKey = __webpack_require__(288),
    isStrictComparable = __webpack_require__(448),
    matchesStrictComparable = __webpack_require__(449),
    toKey = __webpack_require__(135);

/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1,
    COMPARE_UNORDERED_FLAG = 2;

/**
 * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
 *
 * @private
 * @param {string} path The path of the property to get.
 * @param {*} srcValue The value to match.
 * @returns {Function} Returns the new spec function.
 */
function baseMatchesProperty(path, srcValue) {
  if (isKey(path) && isStrictComparable(srcValue)) {
    return matchesStrictComparable(toKey(path), srcValue);
  }
  return function(object) {
    var objValue = get(object, path);
    return (objValue === undefined && objValue === srcValue)
      ? hasIn(object, path)
      : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
  };
}

module.exports = baseMatchesProperty;

/***/ }),
/* 993 */
/***/ (function(module, exports) {

/**
 * The base implementation of `_.property` without support for deep paths.
 *
 * @private
 * @param {string} key The key of the property to get.
 * @returns {Function} Returns the new accessor function.
 */
function baseProperty(key) {
  return function(object) {
    return object == null ? undefined : object[key];
  };
}

module.exports = baseProperty;

/***/ }),
/* 994 */
/***/ (function(module, exports, __webpack_require__) {

var baseGet = __webpack_require__(281);

/**
 * A specialized version of `baseProperty` which supports deep paths.
 *
 * @private
 * @param {Array|string} path The path of the property to get.
 * @returns {Function} Returns the new accessor function.
 */
function basePropertyDeep(path) {
  return function(object) {
    return baseGet(object, path);
  };
}

module.exports = basePropertyDeep;

/***/ }),
/* 995 */
/***/ (function(module, exports) {

/**
 * The base implementation of `_.propertyOf` without support for deep paths.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Function} Returns the new accessor function.
 */
function basePropertyOf(object) {
  return function(key) {
    return object == null ? undefined : object[key];
  };
}

module.exports = basePropertyOf;

/***/ }),
/* 996 */
/***/ (function(module, exports, __webpack_require__) {

var constant = __webpack_require__(1077),
    defineProperty = __webpack_require__(437),
    identity = __webpack_require__(178);

module.exports = baseSetToString;

/***/ }),
/* 997 */
/***/ (function(module, exports) {

while (++index < n) {
    result[index] = iteratee(index);
  }
  return result;
}

module.exports = baseTimes;

/***/ }),
/* 998 */
/***/ (function(module, exports, __webpack_require__) {

var Symbol = __webpack_require__(106),
    arrayMap = __webpack_require__(107),
    isArray = __webpack_require__(27),
    isSymbol = __webpack_require__(183);

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;

/** Used to convert symbols to primitives and strings. */
var symbolProto = Symbol ? Symbol.prototype : undefined,
    symbolToString = symbolProto ? symbolProto.toString : undefined;

/**
 * The base implementation of `_.toString` which doesn't convert nullish
 * values to empty strings.
 *
 * @private
 * @param {*} value The value to process.
 * @returns {string} Returns the string.
 */
function baseToString(value) {
  // Exit early for strings to avoid a performance hit in some environments.
  if (typeof value == 'string') {
    return value;
  }
  if (isArray(value)) {
    // Recursively convert values (susceptible to call stack limits).
    return arrayMap(value, baseToString) + '';
  }
  if (isSymbol(value)) {
    return symbolToString ? symbolToString.call(value) : '';
  }
  var result = (value + '');
  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
}

module.exports = baseToString;

/***/ }),
/* 999 */
/***/ (function(module, exports, __webpack_require__) {

var trimmedEndIndex = __webpack_require__(1069);

/** Used to match leading whitespace. */
var reTrimStart = /^\s+/;

/**
 * The base implementation of `_.trim`.
 *
 * @private
 * @param {string} string The string to trim.
 * @returns {string} Returns the trimmed string.
 */
function baseTrim(string) {
  return string
    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
    : string;
}

module.exports = baseTrim;

/***/ }),
/* 1000 */
/***/ (function(module, exports, __webpack_require__) {

var castPath = __webpack_require__(175),
    last = __webpack_require__(1089),
    parent = __webpack_require__(1056),
    toKey = __webpack_require__(135);

/**
 * The base implementation of `_.unset`.
 *
 * @private
 * @param {Object} object The object to modify.
 * @param {Array|string} path The property path to unset.
 * @returns {boolean} Returns `true` if the property is deleted, else `false`.
 */
function baseUnset(object, path) {
  path = castPath(path, object);
  object = parent(object, path);
  return object == null || delete object[toKey(last(path))];
}

module.exports = baseUnset;

/***/ }),
/* 1001 */
/***/ (function(module, exports, __webpack_require__) {

var baseDifference = __webpack_require__(428),
    baseFlatten = __webpack_require__(280),
    baseUniq = __webpack_require__(434);

/**
 * The base implementation of methods like `_.xor`, without support for
 * iteratee shorthands, that accepts an array of arrays to inspect.
 *
 * @private
 * @param {Array} arrays The arrays to inspect.
 * @param {Function} [iteratee] The iteratee invoked per element.
 * @param {Function} [comparator] The comparator invoked per element.
 * @returns {Array} Returns the new array of values.
 */
function baseXor(arrays, iteratee, comparator) {
  var length = arrays.length;
  if (length < 2) {
    return length ? baseUniq(arrays[0]) : [];
  }
  var index = -1,
      result = Array(length);

while (++index < length) {
    var array = arrays[index],
        othIndex = -1;

while (++othIndex < length) {
      if (othIndex != index) {
        result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
      }
    }
  }
  return baseUniq(baseFlatten(result, 1), iteratee, comparator);
}

module.exports = baseXor;

/***/ }),
/* 1002 */
/***/ (function(module, exports, __webpack_require__) {

var isArrayLikeObject = __webpack_require__(180);

/**
 * Casts `value` to an empty array if it's not an array like object.
 *
 * @private
 * @param {*} value The value to inspect.
 * @returns {Array|Object} Returns the cast array-like object.
 */
function castArrayLikeObject(value) {
  return isArrayLikeObject(value) ? value : [];
}

module.exports = castArrayLikeObject;

/***/ }),
/* 1003 */
/***/ (function(module, exports, __webpack_require__) {

var baseSlice = __webpack_require__(433);

/**
 * Casts `array` to a slice if it's needed.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {number} start The start position.
 * @param {number} [end=array.length] The end position.
 * @returns {Array} Returns the cast slice.
 */
function castSlice(array, start, end) {
  var length = array.length;
  end = end === undefined ? length : end;
  return (!start && end >= length) ? array : baseSlice(array, start, end);
}

module.exports = castSlice;

/***/ }),
/* 1004 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(45);

/** Detect free variable `exports`. */
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;

/** Built-in value references. */
var Buffer = moduleExports ? root.Buffer : undefined,
    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;

buffer.copy(result);
  return result;
}

module.exports = cloneBuffer;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(201)(module)))

/***/ }),
/* 1005 */
/***/ (function(module, exports, __webpack_require__) {

var cloneArrayBuffer = __webpack_require__(284);

/**
 * Creates a clone of `dataView`.
 *
 * @private
 * @param {Object} dataView The data view to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Object} Returns the cloned data view.
 */
function cloneDataView(dataView, isDeep) {
  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
}

module.exports = cloneDataView;

/***/ }),
/* 1006 */
/***/ (function(module, exports) {

/** Used to match `RegExp` flags from their coerced string values. */
var reFlags = /\w*$/;

/**
 * Creates a clone of `regexp`.
 *
 * @private
 * @param {Object} regexp The regexp to clone.
 * @returns {Object} Returns the cloned regexp.
 */
function cloneRegExp(regexp) {
  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
  result.lastIndex = regexp.lastIndex;
  return result;
}

module.exports = cloneRegExp;

/***/ }),
/* 1007 */
/***/ (function(module, exports, __webpack_require__) {

var Symbol = __webpack_require__(106);

/** Used to convert symbols to primitives and strings. */
var symbolProto = Symbol ? Symbol.prototype : undefined,
    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;

/**
 * Creates a clone of the `symbol` object.
 *
 * @private
 * @param {Object} symbol The symbol object to clone.
 * @returns {Object} Returns the cloned symbol object.
 */
function cloneSymbol(symbol) {
  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
}

module.exports = cloneSymbol;

/***/ }),
/* 1008 */
/***/ (function(module, exports, __webpack_require__) {

var cloneArrayBuffer = __webpack_require__(284);

module.exports = cloneTypedArray;

/***/ }),
/* 1009 */
/***/ (function(module, exports, __webpack_require__) {

var copyObject = __webpack_require__(109),
    getSymbols = __webpack_require__(286);

/**
 * Copies own symbols of `source` to `object`.
 *
 * @private
 * @param {Object} source The object to copy symbols from.
 * @param {Object} [object={}] The object to copy symbols to.
 * @returns {Object} Returns `object`.
 */
function copySymbols(source, object) {
  return copyObject(source, getSymbols(source), object);
}

module.exports = copySymbols;

/***/ }),
/* 1010 */
/***/ (function(module, exports, __webpack_require__) {

var copyObject = __webpack_require__(109),
    getSymbolsIn = __webpack_require__(445);

/**
 * Copies own and inherited symbols of `source` to `object`.
 *
 * @private
 * @param {Object} source The object to copy symbols from.
 * @param {Object} [object={}] The object to copy symbols to.
 * @returns {Object} Returns `object`.
 */
function copySymbolsIn(source, object) {
  return copyObject(source, getSymbolsIn(source), object);
}

module.exports = copySymbolsIn;

/***/ }),
/* 1011 */
/***/ (function(module, exports, __webpack_require__) {

var root = __webpack_require__(45);

/** Used to detect overreaching core-js shims. */
var coreJsData = root['__core-js_shared__'];

module.exports = coreJsData;

/***/ }),
/* 1012 */
/***/ (function(module, exports, __webpack_require__) {

var baseRest = __webpack_require__(108),
    isIterateeCall = __webpack_require__(447);

customizer = (assigner.length > 3 && typeof customizer == 'function')
      ? (length--, customizer)
      : undefined;

module.exports = createAssigner;

/***/ }),
/* 1013 */
/***/ (function(module, exports, __webpack_require__) {

var isArrayLike = __webpack_require__(73);

/**
 * Creates a `baseEach` or `baseEachRight` function.
 *
 * @private
 * @param {Function} eachFunc The function to iterate over a collection.
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {Function} Returns the new base function.
 */
function createBaseEach(eachFunc, fromRight) {
  return function(collection, iteratee) {
    if (collection == null) {
      return collection;
    }
    if (!isArrayLike(collection)) {
      return eachFunc(collection, iteratee);
    }
    var length = collection.length,
        index = fromRight ? length : -1,
        iterable = Object(collection);

while ((fromRight ? index-- : ++index < length)) {
      if (iteratee(iterable[index], index, iterable) === false) {
        break;
      }
    }
    return collection;
  };
}

module.exports = createBaseEach;

/***/ }),
/* 1014 */
/***/ (function(module, exports) {

while (length--) {
      var key = props[fromRight ? length : ++index];
      if (iteratee(iterable[key], key, iterable) === false) {
        break;
      }
    }
    return object;
  };
}

module.exports = createBaseFor;

/***/ }),
/* 1015 */
/***/ (function(module, exports, __webpack_require__) {

var castSlice = __webpack_require__(1003),
    hasUnicode = __webpack_require__(446),
    stringToArray = __webpack_require__(1067),
    toString = __webpack_require__(137);

/**
 * Creates a function like `_.lowerFirst`.
 *
 * @private
 * @param {string} methodName The name of the `String` case method to use.
 * @returns {Function} Returns the new case function.
 */
function createCaseFirst(methodName) {
  return function(string) {
    string = toString(string);

var strSymbols = hasUnicode(string)
      ? stringToArray(string)
      : undefined;

var chr = strSymbols
      ? strSymbols[0]
      : string.charAt(0);

var trailing = strSymbols
      ? castSlice(strSymbols, 1).join('')
      : string.slice(1);

return chr[methodName]() + trailing;
  };
}

module.exports = createCaseFirst;

/***/ }),
/* 1016 */
/***/ (function(module, exports, __webpack_require__) {

var arrayReduce = __webpack_require__(969),
    deburr = __webpack_require__(1078),
    words = __webpack_require__(1097);

/** Used to compose unicode capture groups. */
var rsApos = "['\u2019]";

/** Used to match apostrophes. */
var reApos = RegExp(rsApos, 'g');

/**
 * Creates a function like `_.camelCase`.
 *
 * @private
 * @param {Function} callback The function to combine each word.
 * @returns {Function} Returns the new compounder function.
 */
function createCompounder(callback) {
  return function(string) {
    return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
  };
}

module.exports = createCompounder;

/***/ }),
/* 1017 */
/***/ (function(module, exports, __webpack_require__) {

var LodashWrapper = __webpack_require__(271),
    flatRest = __webpack_require__(439),
    getData = __webpack_require__(443),
    getFuncName = __webpack_require__(444),
    isArray = __webpack_require__(27),
    isLaziable = __webpack_require__(1038);

/** Error message constants. */
var FUNC_ERROR_TEXT = 'Expected a function';

/** Used to compose bitmasks for function metadata. */
var WRAP_CURRY_FLAG = 8,
    WRAP_PARTIAL_FLAG = 32,
    WRAP_ARY_FLAG = 128,
    WRAP_REARG_FLAG = 256;

/**
 * Creates a `_.flow` or `_.flowRight` function.
 *
 * @private
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {Function} Returns the new flow function.
 */
function createFlow(fromRight) {
  return flatRest(function(funcs) {
    var length = funcs.length,
        index = length,
        prereq = LodashWrapper.prototype.thru;

if (fromRight) {
      funcs.reverse();
    }
    while (index--) {
      var func = funcs[index];
      if (typeof func != 'function') {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
        var wrapper = new LodashWrapper([], true);
      }
    }
    index = wrapper ? index : length;
    while (++index < length) {
      func = funcs[index];

var funcName = getFuncName(func),
          data = funcName == 'wrapper' ? getData(func) : undefined;

if (data && isLaziable(data[0]) &&
            data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
            !data[4].length && data[9] == 1
          ) {
        wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
      } else {
        wrapper = (func.length == 1 && isLaziable(func))
          ? wrapper[funcName]()
          : wrapper.thru(func);
      }
    }
    return function() {
      var args = arguments,
          value = args[0];

if (wrapper && args.length == 1 && isArray(value)) {
        return wrapper.plant(value).value();
      }
      var index = 0,
          result = length ? funcs[index].apply(this, args) : value;

while (++index < length) {
        result = funcs[index].call(this, result);
      }
      return result;
    };
  });
}

module.exports = createFlow;

/***/ }),
/* 1018 */
/***/ (function(module, exports, __webpack_require__) {

var Set = __webpack_require__(420),
    noop = __webpack_require__(295),
    setToArray = __webpack_require__(290);

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;

/**
 * Creates a set object of `values`.
 *
 * @private
 * @param {Array} values The values to add to the set.
 * @returns {Object} Returns the new set.
 */
var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
  return new Set(values);
};

module.exports = createSet;

/***/ }),
/* 1019 */
/***/ (function(module, exports, __webpack_require__) {

var isPlainObject = __webpack_require__(48);

/**
 * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
 * objects.
 *
 * @private
 * @param {*} value The value to inspect.
 * @param {string} key The key of the property to inspect.
 * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
 */
function customOmitClone(value) {
  return isPlainObject(value) ? undefined : value;
}

module.exports = customOmitClone;

/***/ }),
/* 1020 */
/***/ (function(module, exports, __webpack_require__) {

var basePropertyOf = __webpack_require__(995);

/** Used to map Latin Unicode letters to basic Latin letters. */
var deburredLetters = {
  // Latin-1 Supplement block.
  '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
  '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
  '\xc7': 'C',  '\xe7': 'c',
  '\xd0': 'D',  '\xf0': 'd',
  '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
  '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
  '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
  '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
  '\xd1': 'N',  '\xf1': 'n',
  '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
  '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
  '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
  '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
  '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
  '\xc6': 'Ae', '\xe6': 'ae',
  '\xde': 'Th', '\xfe': 'th',
  '\xdf': 'ss',
  // Latin Extended-A block.
  '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
  '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
  '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
  '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
  '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
  '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
  '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
  '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
  '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
  '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
  '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
  '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
  '\u0134': 'J',  '\u0135': 'j',
  '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
  '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
  '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
  '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
  '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
  '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
  '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
  '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
  '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
  '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
  '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
  '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
  '\u0163': 't',  '\u0165': 't', '\u0167': 't',
  '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
  '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
  '\u0174': 'W',  '\u0175': 'w',
  '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
  '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
  '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
  '\u0132': 'IJ', '\u0133': 'ij',
  '\u0152': 'Oe', '\u0153': 'oe',
  '\u0149': "'n", '\u017f': 's'
};

/**
 * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
 * letters to basic Latin letters.
 *
 * @private
 * @param {string} letter The matched letter to deburr.
 * @returns {string} Returns the deburred letter.
 */
var deburrLetter = basePropertyOf(deburredLetters);

module.exports = deburrLetter;

/***/ }),
/* 1021 */
/***/ (function(module, exports, __webpack_require__) {

var Symbol = __webpack_require__(106),
    Uint8Array = __webpack_require__(421),
    eq = __webpack_require__(136),
    equalArrays = __webpack_require__(438),
    mapToArray = __webpack_require__(1050),
    setToArray = __webpack_require__(290);

/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1,
    COMPARE_UNORDERED_FLAG = 2;

/** `Object#toString` result references. */
var boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    symbolTag = '[object Symbol]';

var arrayBufferTag = '[object ArrayBuffer]',
    dataViewTag = '[object DataView]';

/** Used to convert symbols to primitives and strings. */
var symbolProto = Symbol ? Symbol.prototype : undefined,
    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;

/**
 * A specialized version of `baseIsEqualDeep` for comparing objects of
 * the same `toStringTag`.
 *
 * **Note:** This function only supports comparing values with tags of
 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {string} tag The `toStringTag` of the objects to compare.
 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} stack Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
  switch (tag) {
    case dataViewTag:
      if ((object.byteLength != other.byteLength) ||
          (object.byteOffset != other.byteOffset)) {
        return false;
      }
      object = object.buffer;
      other = other.buffer;

case arrayBufferTag:
      if ((object.byteLength != other.byteLength) ||
          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
        return false;
      }
      return true;

case boolTag:
    case dateTag:
    case numberTag:
      // Coerce booleans to `1` or `0` and dates to milliseconds.
      // Invalid dates are coerced to `NaN`.
      return eq(+object, +other);

case errorTag:
      return object.name == other.name && object.message == other.message;

case regexpTag:
    case stringTag:
      // Coerce regexes to strings and treat strings, primitives and objects,
      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
      // for more details.
      return object == (other + '');

case mapTag:
      var convert = mapToArray;

case setTag:
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
      convert || (convert = setToArray);

if (object.size != other.size && !isPartial) {
        return false;
      }
      // Assume cyclic values are equal.
      var stacked = stack.get(object);
      if (stacked) {
        return stacked == other;
      }
      bitmask |= COMPARE_UNORDERED_FLAG;

// Recursively compare objects (susceptible to call stack limits).
      stack.set(object, other);
      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
      stack['delete'](object);
      return result;

case symbolTag:
      if (symbolValueOf) {
        return symbolValueOf.call(object) == symbolValueOf.call(other);
      }
  }
  return false;
}

module.exports = equalByTag;

/***/ }),
/* 1022 */
/***/ (function(module, exports, __webpack_require__) {

var getAllKeys = __webpack_require__(441);

/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1;

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * A specialized version of `baseIsEqualDeep` for objects with support for
 * partial deep comparisons.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
 * @param {Function} customizer The function to customize comparisons.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Object} stack Tracks traversed `object` and `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
      objProps = getAllKeys(object),
      objLength = objProps.length,
      othProps = getAllKeys(other),
      othLength = othProps.length;

if (objLength != othLength && !isPartial) {
    return false;
  }
  var index = objLength;
  while (index--) {
    var key = objProps[index];
    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
      return false;
    }
  }
  // Check that cyclic values are equal.
  var objStacked = stack.get(object);
  var othStacked = stack.get(other);
  if (objStacked && othStacked) {
    return objStacked == other && othStacked == object;
  }
  var result = true;
  stack.set(object, other);
  stack.set(other, object);

var skipCtor = isPartial;
  while (++index < objLength) {
    key = objProps[index];
    var objValue = object[key],
        othValue = other[key];

if (customizer) {
      var compared = isPartial
        ? customizer(othValue, objValue, key, other, object, stack)
        : customizer(objValue, othValue, key, object, other, stack);
    }
    // Recursively compare objects (susceptible to call stack limits).
    if (!(compared === undefined
          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
          : compared
        )) {
      result = false;
      break;
    }
    skipCtor || (skipCtor = key == 'constructor');
  }
  if (result && !skipCtor) {
    var objCtor = object.constructor,
        othCtor = other.constructor;

// Non `Object` object instances with different constructors are not equal.
    if (objCtor != othCtor &&
        ('constructor' in object && 'constructor' in other) &&
        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
          typeof othCtor == 'function' && othCtor instanceof othCtor)) {
      result = false;
    }
  }
  stack['delete'](object);
  stack['delete'](other);
  return result;
}

module.exports = equalObjects;

/***/ }),
/* 1023 */
/***/ (function(module, exports, __webpack_require__) {

var isStrictComparable = __webpack_require__(448),
    keys = __webpack_require__(110);

/**
 * Gets the property names, values, and compare flags of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the match data of `object`.
 */
function getMatchData(object) {
  var result = keys(object),
      length = result.length;

while (length--) {
    var key = result[length],
        value = object[key];

result[length] = [key, value, isStrictComparable(value)];
  }
  return result;
}

module.exports = getMatchData;

/***/ }),
/* 1024 */
/***/ (function(module, exports, __webpack_require__) {

var Symbol = __webpack_require__(106);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString = objectProto.toString;

/** Built-in value references. */
var symToStringTag = Symbol ? Symbol.toStringTag : undefined;

try {
    value[symToStringTag] = undefined;
    var unmasked = true;
  } catch (e) {}

var result = nativeObjectToString.call(value);
  if (unmasked) {
    if (isOwn) {
      value[symToStringTag] = tag;
    } else {
      delete value[symToStringTag];
    }
  }
  return result;
}

module.exports = getRawTag;

/***/ }),
/* 1025 */
/***/ (function(module, exports) {

module.exports = getValue;

/***/ }),
/* 1026 */
/***/ (function(module, exports, __webpack_require__) {

var castPath = __webpack_require__(175),
    isArguments = __webpack_require__(179),
    isArray = __webpack_require__(27),
    isIndex = __webpack_require__(287),
    isLength = __webpack_require__(293),
    toKey = __webpack_require__(135);

/**
 * Checks if `path` exists on `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array|string} path The path to check.
 * @param {Function} hasFunc The function to check properties.
 * @returns {boolean} Returns `true` if `path` exists, else `false`.
 */
function hasPath(object, path, hasFunc) {
  path = castPath(path, object);

var index = -1,
      length = path.length,
      result = false;

while (++index < length) {
    var key = toKey(path[index]);
    if (!(result = object != null && hasFunc(object, key))) {
      break;
    }
    object = object[key];
  }
  if (result || ++index != length) {
    return result;
  }
  length = object == null ? 0 : object.length;
  return !!length && isLength(length) && isIndex(key, length) &&
    (isArray(object) || isArguments(object));
}

module.exports = hasPath;

/***/ }),
/* 1027 */
/***/ (function(module, exports) {

/** Used to detect strings that need a more robust regexp to match words. */
var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

/**
 * Checks if `string` contains a word composed of Unicode symbols.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {boolean} Returns `true` if a word is found, else `false`.
 */
function hasUnicodeWord(string) {
  return reHasUnicodeWord.test(string);
}

module.exports = hasUnicodeWord;

/***/ }),
/* 1028 */
/***/ (function(module, exports, __webpack_require__) {

var nativeCreate = __webpack_require__(177);

module.exports = hashClear;

/***/ }),
/* 1029 */
/***/ (function(module, exports) {

module.exports = hashDelete;

/***/ }),
/* 1030 */
/***/ (function(module, exports, __webpack_require__) {

var nativeCreate = __webpack_require__(177);

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

module.exports = hashGet;

/***/ }),
/* 1031 */
/***/ (function(module, exports, __webpack_require__) {

var nativeCreate = __webpack_require__(177);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

module.exports = hashHas;

/***/ }),
/* 1032 */
/***/ (function(module, exports, __webpack_require__) {

var nativeCreate = __webpack_require__(177);

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

module.exports = hashSet;

/***/ }),
/* 1033 */
/***/ (function(module, exports) {

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Initializes an array clone.
 *
 * @private
 * @param {Array} array The array to clone.
 * @returns {Array} Returns the initialized clone.
 */
function initCloneArray(array) {
  var length = array.length,
      result = new array.constructor(length);

// Add properties assigned by `RegExp#exec`.
  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
    result.index = array.index;
    result.input = array.input;
  }
  return result;
}

module.exports = initCloneArray;

/***/ }),
/* 1034 */
/***/ (function(module, exports, __webpack_require__) {

var cloneArrayBuffer = __webpack_require__(284),
    cloneDataView = __webpack_require__(1005),
    cloneRegExp = __webpack_require__(1006),
    cloneSymbol = __webpack_require__(1007),
    cloneTypedArray = __webpack_require__(1008);

/** `Object#toString` result references. */
var boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    symbolTag = '[object Symbol]';

/**
 * Initializes an object clone based on its `toStringTag`.
 *
 * **Note:** This function only supports cloning values with tags of
 * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
 *
 * @private
 * @param {Object} object The object to clone.
 * @param {string} tag The `toStringTag` of the object to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Object} Returns the initialized clone.
 */
function initCloneByTag(object, tag, isDeep) {
  var Ctor = object.constructor;
  switch (tag) {
    case arrayBufferTag:
      return cloneArrayBuffer(object);

case boolTag:
    case dateTag:
      return new Ctor(+object);

case dataViewTag:
      return cloneDataView(object, isDeep);

case float32Tag: case float64Tag:
    case int8Tag: case int16Tag: case int32Tag:
    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
      return cloneTypedArray(object, isDeep);

case mapTag:
      return new Ctor;

case numberTag:
    case stringTag:
      return new Ctor(object);

case regexpTag:
      return cloneRegExp(object);

case setTag:
      return new Ctor;

case symbolTag:
      return cloneSymbol(object);
  }
}

module.exports = initCloneByTag;

/***/ }),
/* 1035 */
/***/ (function(module, exports, __webpack_require__) {

var baseCreate = __webpack_require__(279),
    getPrototype = __webpack_require__(285),
    isPrototype = __webpack_require__(134);

module.exports = initCloneObject;

/***/ }),
/* 1036 */
/***/ (function(module, exports, __webpack_require__) {

var Symbol = __webpack_require__(106),
    isArguments = __webpack_require__(179),
    isArray = __webpack_require__(27);

/** Built-in value references. */
var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;

module.exports = isFlattenable;

/***/ }),
/* 1037 */
/***/ (function(module, exports) {

module.exports = isKeyable;

/***/ }),
/* 1038 */
/***/ (function(module, exports, __webpack_require__) {

var LazyWrapper = __webpack_require__(270),
    getData = __webpack_require__(443),
    getFuncName = __webpack_require__(444),
    lodash = __webpack_require__(1098);

/**
 * Checks if `func` has a lazy counterpart.
 *
 * @private
 * @param {Function} func The function to check.
 * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
 *  else `false`.
 */
function isLaziable(func) {
  var funcName = getFuncName(func),
      other = lodash[funcName];

if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
    return false;
  }
  if (func === other) {
    return true;
  }
  var data = getData(other);
  return !!data && func === data[0];
}

module.exports = isLaziable;

/***/ }),
/* 1039 */
/***/ (function(module, exports, __webpack_require__) {

var coreJsData = __webpack_require__(1011);

module.exports = isMasked;

/***/ }),
/* 1040 */
/***/ (function(module, exports) {

/**
 * Removes all key-value entries from the list cache.
 *
 * @private
 * @name clear
 * @memberOf ListCache
 */
function listCacheClear() {
  this.__data__ = [];
  this.size = 0;
}

module.exports = listCacheClear;

/***/ }),
/* 1041 */
/***/ (function(module, exports, __webpack_require__) {

var assocIndexOf = __webpack_require__(173);

/** Used for built-in method references. */
var arrayProto = Array.prototype;

/** Built-in value references. */
var splice = arrayProto.splice;

if (index < 0) {
    return false;
  }
  var lastIndex = data.length - 1;
  if (index == lastIndex) {
    data.pop();
  } else {
    splice.call(data, index, 1);
  }
  --this.size;
  return true;
}

module.exports = listCacheDelete;

/***/ }),
/* 1042 */
/***/ (function(module, exports, __webpack_require__) {

var assocIndexOf = __webpack_require__(173);

return index < 0 ? undefined : data[index][1];
}

module.exports = listCacheGet;

/***/ }),
/* 1043 */
/***/ (function(module, exports, __webpack_require__) {

var assocIndexOf = __webpack_require__(173);

module.exports = listCacheHas;

/***/ }),
/* 1044 */
/***/ (function(module, exports, __webpack_require__) {

var assocIndexOf = __webpack_require__(173);

if (index < 0) {
    ++this.size;
    data.push([key, value]);
  } else {
    data[index][1] = value;
  }
  return this;
}

module.exports = listCacheSet;

/***/ }),
/* 1045 */
/***/ (function(module, exports, __webpack_require__) {

var Hash = __webpack_require__(966),
    ListCache = __webpack_require__(171),
    Map = __webpack_require__(272);

module.exports = mapCacheClear;

/***/ }),
/* 1046 */
/***/ (function(module, exports, __webpack_require__) {

var getMapData = __webpack_require__(176);

module.exports = mapCacheDelete;

/***/ }),
/* 1047 */
/***/ (function(module, exports, __webpack_require__) {

var getMapData = __webpack_require__(176);

module.exports = mapCacheGet;

/***/ }),
/* 1048 */
/***/ (function(module, exports, __webpack_require__) {

var getMapData = __webpack_require__(176);

module.exports = mapCacheHas;

/***/ }),
/* 1049 */
/***/ (function(module, exports, __webpack_require__) {

var getMapData = __webpack_require__(176);

data.set(key, value);
  this.size += data.size == size ? 0 : 1;
  return this;
}

module.exports = mapCacheSet;

/***/ }),
/* 1050 */
/***/ (function(module, exports) {

/**
 * Converts `map` to its key-value pairs.
 *
 * @private
 * @param {Object} map The map to convert.
 * @returns {Array} Returns the key-value pairs.
 */
function mapToArray(map) {
  var index = -1,
      result = Array(map.size);

map.forEach(function(value, key) {
    result[++index] = [key, value];
  });
  return result;
}

module.exports = mapToArray;

/***/ }),
/* 1051 */
/***/ (function(module, exports, __webpack_require__) {

var memoize = __webpack_require__(455);

/** Used as the maximum memoize cache size. */
var MAX_MEMOIZE_SIZE = 500;

/**
 * A specialized version of `_.memoize` which clears the memoized function's
 * cache when it exceeds `MAX_MEMOIZE_SIZE`.
 *
 * @private
 * @param {Function} func The function to have its output memoized.
 * @returns {Function} Returns the new memoized function.
 */
function memoizeCapped(func) {
  var result = memoize(func, function(key) {
    if (cache.size === MAX_MEMOIZE_SIZE) {
      cache.clear();
    }
    return key;
  });

var cache = result.cache;
  return result;
}

module.exports = memoizeCapped;

/***/ }),
/* 1052 */
/***/ (function(module, exports, __webpack_require__) {

var WeakMap = __webpack_require__(422);

/** Used to store function metadata. */
var metaMap = WeakMap && new WeakMap;

module.exports = metaMap;

/***/ }),
/* 1053 */
/***/ (function(module, exports, __webpack_require__) {

var overArg = __webpack_require__(450);

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeKeys = overArg(Object.keys, Object);

module.exports = nativeKeys;

/***/ }),
/* 1054 */
/***/ (function(module, exports) {

module.exports = nativeKeysIn;

/***/ }),
/* 1055 */
/***/ (function(module, exports) {

/** Used for built-in method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */
var nativeObjectToString = objectProto.toString;

module.exports = objectToString;

/***/ }),
/* 1056 */
/***/ (function(module, exports, __webpack_require__) {

var baseGet = __webpack_require__(281),
    baseSlice = __webpack_require__(433);

/**
 * Gets the parent value at `path` of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @param {Array} path The path to get the parent value of.
 * @returns {*} Returns the parent value.
 */
function parent(object, path) {
  return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
}

module.exports = parent;

/***/ }),
/* 1057 */
/***/ (function(module, exports) {

/** Used to lookup unminified function names. */
var realNames = {};

module.exports = realNames;

/***/ }),
/* 1058 */
/***/ (function(module, exports) {

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

module.exports = setCacheAdd;

/***/ }),
/* 1059 */
/***/ (function(module, exports) {

module.exports = setCacheHas;

/***/ }),
/* 1060 */
/***/ (function(module, exports) {

/** Used to detect hot functions by number of calls within a span of milliseconds. */
var HOT_COUNT = 800,
    HOT_SPAN = 16;

/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeNow = Date.now;

return function() {
    var stamp = nativeNow(),
        remaining = HOT_SPAN - (stamp - lastCalled);

module.exports = shortOut;

/***/ }),
/* 1061 */
/***/ (function(module, exports, __webpack_require__) {

var ListCache = __webpack_require__(171);

/**
 * Removes all key-value entries from the stack.
 *
 * @private
 * @name clear
 * @memberOf Stack
 */
function stackClear() {
  this.__data__ = new ListCache;
  this.size = 0;
}

module.exports = stackClear;

/***/ }),
/* 1062 */
/***/ (function(module, exports) {

this.size = data.size;
  return result;
}

module.exports = stackDelete;

/***/ }),
/* 1063 */
/***/ (function(module, exports) {

module.exports = stackGet;

/***/ }),
/* 1064 */
/***/ (function(module, exports) {

module.exports = stackHas;

/***/ }),
/* 1065 */
/***/ (function(module, exports, __webpack_require__) {

var ListCache = __webpack_require__(171),
    Map = __webpack_require__(272),
    MapCache = __webpack_require__(273);

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

module.exports = stackSet;

/***/ }),
/* 1066 */
/***/ (function(module, exports) {

/**
 * A specialized version of `_.indexOf` which performs strict equality
 * comparisons of values, i.e. `===`.
 *
 * @private
 * @param {Array} array The array to inspect.
 * @param {*} value The value to search for.
 * @param {number} fromIndex The index to search from.
 * @returns {number} Returns the index of the matched value, else `-1`.
 */
function strictIndexOf(array, value, fromIndex) {
  var index = fromIndex - 1,
      length = array.length;

while (++index < length) {
    if (array[index] === value) {
      return index;
    }
  }
  return -1;
}

module.exports = strictIndexOf;

/***/ }),
/* 1067 */
/***/ (function(module, exports, __webpack_require__) {

var asciiToArray = __webpack_require__(971),
    hasUnicode = __webpack_require__(446),
    unicodeToArray = __webpack_require__(1070);

/**
 * Converts `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function stringToArray(string) {
  return hasUnicode(string)
    ? unicodeToArray(string)
    : asciiToArray(string);
}

module.exports = stringToArray;

/***/ }),
/* 1068 */
/***/ (function(module, exports, __webpack_require__) {

var memoizeCapped = __webpack_require__(1051);

/** Used to match property names within property paths. */
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

/** Used to match backslashes in property paths. */
var reEscapeChar = /\$\$?/g;

/**
 * Converts `string` to a property path array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the property path array.
 */
var stringToPath = memoizeCapped(function(string) {
  var result = [];
  if (string.charCodeAt(0) === 46 /* . */) {
    result.push('');
  }
  string.replace(rePropName, function(match, number, quote, subString) {
    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
  });
  return result;
});

module.exports = stringToPath;

/***/ }),
/* 1069 */
/***/ (function(module, exports) {

/** Used to match a single whitespace character. */
var reWhitespace = /\s/;

/**
 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
 * character of `string`.
 *
 * @private
 * @param {string} string The string to inspect.
 * @returns {number} Returns the index of the last non-whitespace character.
 */
function trimmedEndIndex(string) {
  var index = string.length;

while (index-- && reWhitespace.test(string.charAt(index))) {}
  return index;
}

module.exports = trimmedEndIndex;

/***/ }),
/* 1070 */
/***/ (function(module, exports) {

/** Used to compose unicode capture groups. */
var rsAstral = '[' + rsAstralRange + ']',
    rsCombo = '[' + rsComboRange + ']',
    rsFitz = '\\ud83c[\\udffb-\\udfff]',
    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
    rsNonAstral = '[^' + rsAstralRange + ']',
    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
    rsZWJ = '\\u200d';

/** Used to compose unicode regexes. */
var reOptMod = rsModifier + '?',
    rsOptVar = '[' + rsVarRange + ']?',
    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
    rsSeq = rsOptVar + reOptMod + rsOptJoin,
    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

/**
 * Converts a Unicode `string` to an array.
 *
 * @private
 * @param {string} string The string to convert.
 * @returns {Array} Returns the converted array.
 */
function unicodeToArray(string) {
  return string.match(reUnicode) || [];
}

module.exports = unicodeToArray;

/***/ }),
/* 1071 */
/***/ (function(module, exports) {

/** Used to compose unicode character classes. */
var rsAstralRange = '\\ud800-\\udfff',
    rsComboMarksRange = '\\u0300-\\u036f',
    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
    rsComboSymbolsRange = '\\u20d0-\\u20ff',
    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
    rsDingbatRange = '\\u2700-\\u27bf',
    rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
    rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
    rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
    rsPunctuationRange = '\\u2000-\\u206f',
    rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
    rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
    rsVarRange = '\\ufe0e\\ufe0f',
    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

/** Used to compose unicode capture groups. */
var rsApos = "['\u2019]",
    rsBreak = '[' + rsBreakRange + ']',
    rsCombo = '[' + rsComboRange + ']',
    rsDigits = '\\d+',
    rsDingbat = '[' + rsDingbatRange + ']',
    rsLower = '[' + rsLowerRange + ']',
    rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
    rsFitz = '\\ud83c[\\udffb-\\udfff]',
    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
    rsNonAstral = '[^' + rsAstralRange + ']',
    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
    rsUpper = '[' + rsUpperRange + ']',
    rsZWJ = '\\u200d';

/** Used to compose unicode regexes. */
var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
    rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
    rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
    rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
    reOptMod = rsModifier + '?',
    rsOptVar = '[' + rsVarRange + ']?',
    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
    rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
    rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
    rsSeq = rsOptVar + reOptMod + rsOptJoin,
    rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq;

/** Used to match complex or compound words. */
var reUnicodeWord = RegExp([
  rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
  rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
  rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
  rsUpper + '+' + rsOptContrUpper,
  rsOrdUpper,
  rsOrdLower,
  rsDigits,
  rsEmoji
].join('|'), 'g');

/**
 * Splits a Unicode `string` into an array of its words.
 *
 * @private
 * @param {string} The string to inspect.
 * @returns {Array} Returns the words of `string`.
 */
function unicodeWords(string) {
  return string.match(reUnicodeWord) || [];
}

module.exports = unicodeWords;

/***/ }),
/* 1072 */
/***/ (function(module, exports, __webpack_require__) {

var LazyWrapper = __webpack_require__(270),
    LodashWrapper = __webpack_require__(271),
    copyArray = __webpack_require__(436);

/**
 * Creates a clone of `wrapper`.
 *
 * @private
 * @param {Object} wrapper The wrapper to clone.
 * @returns {Object} Returns the cloned wrapper.
 */
function wrapperClone(wrapper) {
  if (wrapper instanceof LazyWrapper) {
    return wrapper.clone();
  }
  var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
  result.__actions__ = copyArray(wrapper.__actions__);
  result.__index__  = wrapper.__index__;
  result.__values__ = wrapper.__values__;
  return result;
}

module.exports = wrapperClone;

/***/ }),
/* 1073 */
/***/ (function(module, exports, __webpack_require__) {

var assignValue = __webpack_require__(278),
    copyObject = __webpack_require__(109),
    createAssigner = __webpack_require__(1012),
    isArrayLike = __webpack_require__(73),
    isPrototype = __webpack_require__(134),
    keys = __webpack_require__(110);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Assigns own enumerable string keyed properties of source objects to the
 * destination object. Source objects are applied from left to right.
 * Subsequent sources overwrite property assignments of previous sources.
 *
 * **Note:** This method mutates `object` and is loosely based on
 * [`Object.assign`](https://mdn.io/Object/assign).
 *
 * @static
 * @memberOf _
 * @since 0.10.0
 * @category Object
 * @param {Object} object The destination object.
 * @param {...Object} [sources] The source objects.
 * @returns {Object} Returns `object`.
 * @see _.assignIn
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 * }
 *
 * function Bar() {
 *   this.c = 3;
 * }
 *
 * Foo.prototype.b = 2;
 * Bar.prototype.d = 4;
 *
 * _.assign({ 'a': 0 }, new Foo, new Bar);
 * // => { 'a': 1, 'c': 3 }
 */
var assign = createAssigner(function(object, source) {
  if (isPrototype(source) || isArrayLike(source)) {
    copyObject(source, keys(source), object);
    return;
  }
  for (var key in source) {
    if (hasOwnProperty.call(source, key)) {
      assignValue(object, key, source[key]);
    }
  }
});

module.exports = assign;

/***/ }),
/* 1074 */
/***/ (function(module, exports, __webpack_require__) {

var capitalize = __webpack_require__(1075),
    createCompounder = __webpack_require__(1016);

/**
 * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category String
 * @param {string} [string=''] The string to convert.
 * @returns {string} Returns the camel cased string.
 * @example
 *
 * _.camelCase('Foo Bar');
 * // => 'fooBar'
 *
 * _.camelCase('--foo-bar--');
 * // => 'fooBar'
 *
 * _.camelCase('__FOO_BAR__');
 * // => 'fooBar'
 */
var camelCase = createCompounder(function(result, word, index) {
  word = word.toLowerCase();
  return result + (index ? capitalize(word) : word);
});

module.exports = camelCase;

/***/ }),
/* 1075 */
/***/ (function(module, exports, __webpack_require__) {

var toString = __webpack_require__(137),
    upperFirst = __webpack_require__(1096);

/**
 * Converts the first character of `string` to upper case and the remaining
 * to lower case.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category String
 * @param {string} [string=''] The string to capitalize.
 * @returns {string} Returns the capitalized string.
 * @example
 *
 * _.capitalize('FRED');
 * // => 'Fred'
 */
function capitalize(string) {
  return upperFirst(toString(string).toLowerCase());
}

module.exports = capitalize;

/***/ }),
/* 1076 */
/***/ (function(module, exports, __webpack_require__) {

var baseClone = __webpack_require__(427);

/** Used to compose bitmasks for cloning. */
var CLONE_DEEP_FLAG = 1,
    CLONE_SYMBOLS_FLAG = 4;

/**
 * This method is like `_.clone` except that it recursively clones `value`.
 *
 * @static
 * @memberOf _
 * @since 1.0.0
 * @category Lang
 * @param {*} value The value to recursively clone.
 * @returns {*} Returns the deep cloned value.
 * @see _.clone
 * @example
 *
 * var objects = [{ 'a': 1 }, { 'b': 2 }];
 *
 * var deep = _.cloneDeep(objects);
 * console.log(deep[0] === objects[0]);
 * // => false
 */
function cloneDeep(value) {
  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
}

module.exports = cloneDeep;

/***/ }),
/* 1077 */
/***/ (function(module, exports) {

module.exports = constant;

/***/ }),
/* 1078 */
/***/ (function(module, exports, __webpack_require__) {

var deburrLetter = __webpack_require__(1020),
    toString = __webpack_require__(137);

/** Used to match Latin Unicode letters (excluding mathematical operators). */
var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

/** Used to compose unicode character classes. */
var rsComboMarksRange = '\\u0300-\\u036f',
    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
    rsComboSymbolsRange = '\\u20d0-\\u20ff',
    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;

/** Used to compose unicode capture groups. */
var rsCombo = '[' + rsComboRange + ']';

/**
 * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
 * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
 */
var reComboMark = RegExp(rsCombo, 'g');

/**
 * Deburrs `string` by converting
 * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
 * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
 * letters to basic Latin letters and removing
 * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category String
 * @param {string} [string=''] The string to deburr.
 * @returns {string} Returns the deburred string.
 * @example
 *
 * _.deburr('déjà vu');
 * // => 'deja vu'
 */
function deburr(string) {
  string = toString(string);
  return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
}

module.exports = deburr;

/***/ }),
/* 1079 */
/***/ (function(module, exports, __webpack_require__) {

var baseRest = __webpack_require__(108),
    eq = __webpack_require__(136),
    isIterateeCall = __webpack_require__(447),
    keysIn = __webpack_require__(184);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Assigns own and inherited enumerable string keyed properties of source
 * objects to the destination object for all destination properties that
 * resolve to `undefined`. Source objects are applied from left to right.
 * Once a property is set, additional values of the same property are ignored.
 *
 * **Note:** This method mutates `object`.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Object
 * @param {Object} object The destination object.
 * @param {...Object} [sources] The source objects.
 * @returns {Object} Returns `object`.
 * @see _.defaultsDeep
 * @example
 *
 * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
 * // => { 'a': 1, 'b': 2 }
 */
var defaults = baseRest(function(object, sources) {
  object = Object(object);

var index = -1;
  var length = sources.length;
  var guard = length > 2 ? sources[2] : undefined;

if (guard && isIterateeCall(sources[0], sources[1], guard)) {
    length = 1;
  }

while (++index < length) {
    var source = sources[index];
    var props = keysIn(source);
    var propsIndex = -1;
    var propsLength = props.length;

while (++propsIndex < propsLength) {
      var key = props[propsIndex];
      var value = object[key];

if (value === undefined ||
          (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
        object[key] = source[key];
      }
    }
  }

return object;
});

module.exports = defaults;

/***/ }),
/* 1080 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(1082);

/***/ }),
/* 1081 */
/***/ (function(module, exports, __webpack_require__) {

var baseFlatten = __webpack_require__(280);

/**
 * Flattens `array` a single level deep.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Array
 * @param {Array} array The array to flatten.
 * @returns {Array} Returns the new flattened array.
 * @example
 *
 * _.flatten([1, [2, [3, [4]], 5]]);
 * // => [1, 2, [3, [4]], 5]
 */
function flatten(array) {
  var length = array == null ? 0 : array.length;
  return length ? baseFlatten(array, 1) : [];
}

module.exports = flatten;

/***/ }),
/* 1082 */
/***/ (function(module, exports, __webpack_require__) {

var arrayEach = __webpack_require__(423),
    baseEach = __webpack_require__(429),
    castFunction = __webpack_require__(435),
    isArray = __webpack_require__(27);

/**
 * Iterates over elements of `collection` and invokes `iteratee` for each element.
 * The iteratee is invoked with three arguments: (value, index|key, collection).
 * Iteratee functions may exit iteration early by explicitly returning `false`.
 *
 * **Note:** As with other "Collections" methods, objects with a "length"
 * property are iterated like arrays. To avoid this behavior use `_.forIn`
 * or `_.forOwn` for object iteration.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @alias each
 * @category Collection
 * @param {Array|Object} collection The collection to iterate over.
 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
 * @returns {Array|Object} Returns `collection`.
 * @see _.forEachRight
 * @example
 *
 * _.forEach([1, 2], function(value) {
 *   console.log(value);
 * });
 * // => Logs `1` then `2`.
 *
 * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
 *   console.log(key);
 * });
 * // => Logs 'a' then 'b' (iteration order is not guaranteed).
 */
function forEach(collection, iteratee) {
  var func = isArray(collection) ? arrayEach : baseEach;
  return func(collection, castFunction(iteratee));
}

module.exports = forEach;

/***/ }),
/* 1083 */
/***/ (function(module, exports, __webpack_require__) {

var baseGet = __webpack_require__(281);

/**
 * Gets the value at `path` of `object`. If the resolved value is
 * `undefined`, the `defaultValue` is returned in its place.
 *
 * @static
 * @memberOf _
 * @since 3.7.0
 * @category Object
 * @param {Object} object The object to query.
 * @param {Array|string} path The path of the property to get.
 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
 * @returns {*} Returns the resolved value.
 * @example
 *
 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
 *
 * _.get(object, 'a[0].b.c');
 * // => 3
 *
 * _.get(object, ['a', '0', 'b', 'c']);
 * // => 3
 *
 * _.get(object, 'a.b.c', 'default');
 * // => 'default'
 */
function get(object, path, defaultValue) {
  var result = object == null ? undefined : baseGet(object, path);
  return result === undefined ? defaultValue : result;
}

module.exports = get;

/***/ }),
/* 1084 */
/***/ (function(module, exports, __webpack_require__) {

var baseHasIn = __webpack_require__(977),
    hasPath = __webpack_require__(1026);

/**
 * Checks if `path` is a direct or inherited property of `object`.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Object
 * @param {Object} object The object to query.
 * @param {Array|string} path The path to check.
 * @returns {boolean} Returns `true` if `path` exists, else `false`.
 * @example
 *
 * var object = _.create({ 'a': _.create({ 'b': 2 }) });
 *
 * _.hasIn(object, 'a');
 * // => true
 *
 * _.hasIn(object, 'a.b');
 * // => true
 *
 * _.hasIn(object, ['a', 'b']);
 * // => true
 *
 * _.hasIn(object, 'b');
 * // => false
 */
function hasIn(object, path) {
  return object != null && hasPath(object, path, baseHasIn);
}

module.exports = hasIn;

/***/ }),
/* 1085 */
/***/ (function(module, exports, __webpack_require__) {

var arrayMap = __webpack_require__(107),
    baseIntersection = __webpack_require__(979),
    baseRest = __webpack_require__(108),
    castArrayLikeObject = __webpack_require__(1002);

/**
 * Creates an array of unique values that are included in all given arrays
 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons. The order and references of result values are
 * determined by the first array.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Array
 * @param {...Array} [arrays] The arrays to inspect.
 * @returns {Array} Returns the new array of intersecting values.
 * @example
 *
 * _.intersection([2, 1], [2, 3]);
 * // => [2]
 */
var intersection = baseRest(function(arrays) {
  var mapped = arrayMap(arrays, castArrayLikeObject);
  return (mapped.length && mapped[0] === arrays[0])
    ? baseIntersection(mapped)
    : [];
});

module.exports = intersection;

/***/ }),
/* 1086 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsMap = __webpack_require__(982),
    baseUnary = __webpack_require__(132),
    nodeUtil = __webpack_require__(289);

/* Node.js helper references. */
var nodeIsMap = nodeUtil && nodeUtil.isMap;

/**
 * Checks if `value` is classified as a `Map` object.
 *
 * @static
 * @memberOf _
 * @since 4.3.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a map, else `false`.
 * @example
 *
 * _.isMap(new Map);
 * // => true
 *
 * _.isMap(new WeakMap);
 * // => false
 */
var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;

module.exports = isMap;

/***/ }),
/* 1087 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsSet = __webpack_require__(986),
    baseUnary = __webpack_require__(132),
    nodeUtil = __webpack_require__(289);

/* Node.js helper references. */
var nodeIsSet = nodeUtil && nodeUtil.isSet;

/**
 * Checks if `value` is classified as a `Set` object.
 *
 * @static
 * @memberOf _
 * @since 4.3.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a set, else `false`.
 * @example
 *
 * _.isSet(new Set);
 * // => true
 *
 * _.isSet(new WeakSet);
 * // => false
 */
var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;

module.exports = isSet;

/***/ }),
/* 1088 */
/***/ (function(module, exports, __webpack_require__) {

var baseGetTag = __webpack_require__(84),
    isArray = __webpack_require__(27),
    isObjectLike = __webpack_require__(47);

/** `Object#toString` result references. */
var stringTag = '[object String]';

/**
 * Checks if `value` is classified as a `String` primitive or object.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a string, else `false`.
 * @example
 *
 * _.isString('abc');
 * // => true
 *
 * _.isString(1);
 * // => false
 */
function isString(value) {
  return typeof value == 'string' ||
    (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
}

module.exports = isString;

/***/ }),
/* 1089 */
/***/ (function(module, exports) {

/**
 * Gets the last element of `array`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Array
 * @param {Array} array The array to query.
 * @returns {*} Returns the last element of `array`.
 * @example
 *
 * _.last([1, 2, 3]);
 * // => 3
 */
function last(array) {
  var length = array == null ? 0 : array.length;
  return length ? array[length - 1] : undefined;
}

module.exports = last;

/***/ }),
/* 1090 */
/***/ (function(module, exports, __webpack_require__) {

var root = __webpack_require__(45);

module.exports = now;

/***/ }),
/* 1091 */
/***/ (function(module, exports, __webpack_require__) {

var arrayMap = __webpack_require__(107),
    baseClone = __webpack_require__(427),
    baseUnset = __webpack_require__(1000),
    castPath = __webpack_require__(175),
    copyObject = __webpack_require__(109),
    customOmitClone = __webpack_require__(1019),
    flatRest = __webpack_require__(439),
    getAllKeysIn = __webpack_require__(442);

/** Used to compose bitmasks for cloning. */
var CLONE_DEEP_FLAG = 1,
    CLONE_FLAT_FLAG = 2,
    CLONE_SYMBOLS_FLAG = 4;

/**
 * The opposite of `_.pick`; this method creates an object composed of the
 * own and inherited enumerable property paths of `object` that are not omitted.
 *
 * **Note:** This method is considerably slower than `_.pick`.
 *
 * @static
 * @since 0.1.0
 * @memberOf _
 * @category Object
 * @param {Object} object The source object.
 * @param {...(string|string[])} [paths] The property paths to omit.
 * @returns {Object} Returns the new object.
 * @example
 *
 * var object = { 'a': 1, 'b': '2', 'c': 3 };
 *
 * _.omit(object, ['a', 'c']);
 * // => { 'b': '2' }
 */
var omit = flatRest(function(object, paths) {
  var result = {};
  if (object == null) {
    return result;
  }
  var isDeep = false;
  paths = arrayMap(paths, function(path) {
    path = castPath(path, object);
    isDeep || (isDeep = path.length > 1);
    return path;
  });
  copyObject(object, getAllKeysIn(object), result);
  if (isDeep) {
    result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
  }
  var length = paths.length;
  while (length--) {
    baseUnset(result, paths[length]);
  }
  return result;
});

module.exports = omit;

/***/ }),
/* 1092 */
/***/ (function(module, exports, __webpack_require__) {

var baseProperty = __webpack_require__(993),
    basePropertyDeep = __webpack_require__(994),
    isKey = __webpack_require__(288),
    toKey = __webpack_require__(135);

/**
 * Creates a function that returns the value at `path` of a given object.
 *
 * @static
 * @memberOf _
 * @since 2.4.0
 * @category Util
 * @param {Array|string} path The path of the property to get.
 * @returns {Function} Returns the new accessor function.
 * @example
 *
 * var objects = [
 *   { 'a': { 'b': 2 } },
 *   { 'a': { 'b': 1 } }
 * ];
 *
 * _.map(objects, _.property('a.b'));
 * // => [2, 1]
 *
 * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
 * // => [1, 2]
 */
function property(path) {
  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
}

module.exports = property;

/***/ }),
/* 1093 */
/***/ (function(module, exports) {

module.exports = stubFalse;

/***/ }),
/* 1094 */
/***/ (function(module, exports, __webpack_require__) {

var baseTrim = __webpack_require__(999),
    isObject = __webpack_require__(46),
    isSymbol = __webpack_require__(183);

/** Used as references for various `Number` constants. */
var NAN = 0 / 0;

/** Used to detect bad signed hexadecimal string values. */
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

/** Used to detect binary string values. */
var reIsBinary = /^0b[01]+$/i;

/** Used to detect octal string values. */
var reIsOctal = /^0o[0-7]+$/i;

/** Built-in method references without a dependency on `root`. */
var freeParseInt = parseInt;

/**
 * Converts `value` to a number.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to process.
 * @returns {number} Returns the number.
 * @example
 *
 * _.toNumber(3.2);
 * // => 3.2
 *
 * _.toNumber(Number.MIN_VALUE);
 * // => 5e-324
 *
 * _.toNumber(Infinity);
 * // => Infinity
 *
 * _.toNumber('3.2');
 * // => 3.2
 */
function toNumber(value) {
  if (typeof value == 'number') {
    return value;
  }
  if (isSymbol(value)) {
    return NAN;
  }
  if (isObject(value)) {
    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
    value = isObject(other) ? (other + '') : other;
  }
  if (typeof value != 'string') {
    return value === 0 ? value : +value;
  }
  value = baseTrim(value);
  var isBinary = reIsBinary.test(value);
  return (isBinary || reIsOctal.test(value))
    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
    : (reIsBadHex.test(value) ? NAN : +value);
}

module.exports = toNumber;

/***/ }),
/* 1095 */
/***/ (function(module, exports, __webpack_require__) {

var baseFlatten = __webpack_require__(280),
    baseRest = __webpack_require__(108),
    baseUniq = __webpack_require__(434),
    isArrayLikeObject = __webpack_require__(180);

/**
 * Creates an array of unique values, in order, from all given arrays using
 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
 * for equality comparisons.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Array
 * @param {...Array} [arrays] The arrays to inspect.
 * @returns {Array} Returns the new array of combined values.
 * @example
 *
 * _.union([2], [1, 2]);
 * // => [2, 1]
 */
var union = baseRest(function(arrays) {
  return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
});

module.exports = union;

/***/ }),
/* 1096 */
/***/ (function(module, exports, __webpack_require__) {

var createCaseFirst = __webpack_require__(1015);

/**
 * Converts the first character of `string` to upper case.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category String
 * @param {string} [string=''] The string to convert.
 * @returns {string} Returns the converted string.
 * @example
 *
 * _.upperFirst('fred');
 * // => 'Fred'
 *
 * _.upperFirst('FRED');
 * // => 'FRED'
 */
var upperFirst = createCaseFirst('toUpperCase');

module.exports = upperFirst;

/***/ }),
/* 1097 */
/***/ (function(module, exports, __webpack_require__) {

var asciiWords = __webpack_require__(972),
    hasUnicodeWord = __webpack_require__(1027),
    toString = __webpack_require__(137),
    unicodeWords = __webpack_require__(1071);

/**
 * Splits `string` into an array of its words.
 *
 * @static
 * @memberOf _
 * @since 3.0.0
 * @category String
 * @param {string} [string=''] The string to inspect.
 * @param {RegExp|string} [pattern] The pattern to match words.
 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
 * @returns {Array} Returns the words of `string`.
 * @example
 *
 * _.words('fred, barney, & pebbles');
 * // => ['fred', 'barney', 'pebbles']
 *
 * _.words('fred, barney, & pebbles', /[^, ]+/g);
 * // => ['fred', 'barney', '&', 'pebbles']
 */
function words(string, pattern, guard) {
  string = toString(string);
  pattern = guard ? undefined : pattern;

if (pattern === undefined) {
    return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
  }
  return string.match(pattern) || [];
}

module.exports = words;

/***/ }),
/* 1098 */
/***/ (function(module, exports, __webpack_require__) {

var LazyWrapper = __webpack_require__(270),
    LodashWrapper = __webpack_require__(271),
    baseLodash = __webpack_require__(283),
    isArray = __webpack_require__(27),
    isObjectLike = __webpack_require__(47),
    wrapperClone = __webpack_require__(1072);

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Creates a `lodash` object which wraps `value` to enable implicit method
 * chain sequences. Methods that operate on and return arrays, collections,
 * and functions can be chained together. Methods that retrieve a single value
 * or may return a primitive value will automatically end the chain sequence
 * and return the unwrapped value. Otherwise, the value must be unwrapped
 * with `_#value`.
 *
 * Explicit chain sequences, which must be unwrapped with `_#value`, may be
 * enabled using `_.chain`.
 *
 * The execution of chained methods is lazy, that is, it's deferred until
 * `_#value` is implicitly or explicitly called.
 *
 * Lazy evaluation allows several methods to support shortcut fusion.
 * Shortcut fusion is an optimization to merge iteratee calls; this avoids
 * the creation of intermediate arrays and can greatly reduce the number of
 * iteratee executions. Sections of a chain sequence qualify for shortcut
 * fusion if the section is applied to an array and iteratees accept only
 * one argument. The heuristic for whether a section qualifies for shortcut
 * fusion is subject to change.
 *
 * Chaining is supported in custom builds as long as the `_#value` method is
 * directly or indirectly included in the build.
 *
 * In addition to lodash methods, wrappers have `Array` and `String` methods.
 *
 * The wrapper `Array` methods are:
 * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
 *
 * The wrapper `String` methods are:
 * `replace` and `split`
 *
 * The wrapper methods that support shortcut fusion are:
 * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
 * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
 * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
 *
 * The chainable wrapper methods are:
 * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
 * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
 * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
 * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
 * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
 * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
 * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
 * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
 * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
 * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
 * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
 * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
 * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
 * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
 * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
 * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
 * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
 * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
 * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
 * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
 * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
 * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
 * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
 * `zipObject`, `zipObjectDeep`, and `zipWith`
 *
 * The wrapper methods that are **not** chainable by default are:
 * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
 * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
 * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
 * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
 * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
 * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
 * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
 * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
 * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
 * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
 * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
 * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
 * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
 * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
 * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
 * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
 * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
 * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
 * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
 * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
 * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
 * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
 * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
 * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
 * `upperFirst`, `value`, and `words`
 *
 * @name _
 * @constructor
 * @category Seq
 * @param {*} value The value to wrap in a `lodash` instance.
 * @returns {Object} Returns the new `lodash` wrapper instance.
 * @example
 *
 * function square(n) {
 *   return n * n;
 * }
 *
 * var wrapped = _([1, 2, 3]);
 *
 * // Returns an unwrapped value.
 * wrapped.reduce(_.add);
 * // => 6
 *
 * // Returns a wrapped value.
 * var squares = wrapped.map(square);
 *
 * _.isArray(squares);
 * // => false
 *
 * _.isArray(squares.value());
 * // => true
 */
function lodash(value) {
  if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
    if (value instanceof LodashWrapper) {
      return value;
    }
    if (hasOwnProperty.call(value, '__wrapped__')) {
      return wrapperClone(value);
    }
  }
  return new LodashWrapper(value);
}

// Ensure wrappers are instances of `baseLodash`.
lodash.prototype = baseLodash.prototype;
lodash.prototype.constructor = lodash;

module.exports = lodash;

/***/ }),
/* 1099 */
/***/ (function(module, exports, __webpack_require__) {

var arrayFilter = __webpack_require__(424),
    baseRest = __webpack_require__(108),
    baseXor = __webpack_require__(1001),
    isArrayLikeObject = __webpack_require__(180);

/**
 * Creates an array of unique values that is the
 * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
 * of the given arrays. The order of result values is determined by the order
 * they occur in the arrays.
 *
 * @static
 * @memberOf _
 * @since 2.4.0
 * @category Array
 * @param {...Array} [arrays] The arrays to inspect.
 * @returns {Array} Returns the new array of filtered values.
 * @see _.difference, _.without
 * @example
 *
 * _.xor([2, 1], [2, 3]);
 * // => [1, 3]
 */
var xor = baseRest(function(arrays) {
  return baseXor(arrayFilter(arrays, isArrayLikeObject));
});

module.exports = xor;

/***/ }),
/* 1100 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 * Masonry v4.2.2
 * Cascading grid layout library
 * https://masonry.desandro.com
 * MIT License
 * by David DeSandro
 */

( function( window, factory ) {
  // universal module definition
  /* jshint strict: false */ /*globals define, module, require */
  if ( true ) {
    // AMD
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
        __webpack_require__(1110),
        __webpack_require__(265)
      ], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if ( typeof module == 'object' && module.exports ) {
    // CommonJS
    module.exports = factory(
      require('outlayer'),
      require('get-size')
    );
  } else {
    // browser global
    window.Masonry = factory(
      window.Outlayer,
      window.getSize
    );
  }

}( window, function factory( Outlayer, getSize ) {

'use strict';

// -------------------------- masonryDefinition -------------------------- //

// create an Outlayer layout class
  var Masonry = Outlayer.create('masonry');
  // isFitWidth -> fitWidth
  Masonry.compatOptions.fitWidth = 'isFitWidth';

var proto = Masonry.prototype;

proto._resetLayout = function() {
    this.getSize();
    this._getMeasurement( 'columnWidth', 'outerWidth' );
    this._getMeasurement( 'gutter', 'outerWidth' );
    this.measureColumns();

// reset column Y
    this.colYs = [];
    for ( var i=0; i < this.cols; i++ ) {
      this.colYs.push( 0 );
    }

this.maxY = 0;
    this.horizontalColIndex = 0;
  };

proto.measureColumns = function() {
    this.getContainerWidth();
    // if columnWidth is 0, default to outerWidth of first item
    if ( !this.columnWidth ) {
      var firstItem = this.items[0];
      var firstItemElem = firstItem && firstItem.element;
      // columnWidth fall back to item of first element
      this.columnWidth = firstItemElem && getSize( firstItemElem ).outerWidth ||
        // if first elem has no width, default to size of container
        this.containerWidth;
    }

var columnWidth = this.columnWidth += this.gutter;

// calculate columns
    var containerWidth = this.containerWidth + this.gutter;
    var cols = containerWidth / columnWidth;
    // fix rounding errors, typically with gutters
    var excess = columnWidth - containerWidth % columnWidth;
    // if overshoot is less than a pixel, round up, otherwise floor it
    var mathMethod = excess && excess < 1 ? 'round' : 'floor';
    cols = Math[ mathMethod ]( cols );
    this.cols = Math.max( cols, 1 );
  };

proto.getContainerWidth = function() {
    // container is parent if fit width
    var isFitWidth = this._getOption('fitWidth');
    var container = isFitWidth ? this.element.parentNode : this.element;
    // check that this.size and size are there
    // IE8 triggers resize on body size change, so they might not be
    var size = getSize( container );
    this.containerWidth = size && size.innerWidth;
  };

proto._getItemLayoutPosition = function( item ) {
    item.getSize();
    // how many columns does this brick span
    var remainder = item.size.outerWidth % this.columnWidth;
    var mathMethod = remainder && remainder < 1 ? 'round' : 'ceil';
    // round if off by 1 pixel, otherwise use ceil
    var colSpan = Math[ mathMethod ]( item.size.outerWidth / this.columnWidth );
    colSpan = Math.min( colSpan, this.cols );
    // use horizontal or top column position
    var colPosMethod = this.options.horizontalOrder ?
      '_getHorizontalColPosition' : '_getTopColPosition';
    var colPosition = this[ colPosMethod ]( colSpan, item );
    // position the brick
    var position = {
      x: this.columnWidth * colPosition.col,
      y: colPosition.y
    };
    // apply setHeight to necessary columns
    var setHeight = colPosition.y + item.size.outerHeight;
    var setMax = colSpan + colPosition.col;
    for ( var i = colPosition.col; i < setMax; i++ ) {
      this.colYs[i] = setHeight;
    }

return position;
  };

proto._getTopColPosition = function( colSpan ) {
    var colGroup = this._getTopColGroup( colSpan );
    // get the minimum Y value from the columns
    var minimumY = Math.min.apply( Math, colGroup );

return {
      col: colGroup.indexOf( minimumY ),
      y: minimumY,
    };
  };

/**
   * @param {Number} colSpan - number of columns the element spans
   * @returns {Array} colGroup
   */
  proto._getTopColGroup = function( colSpan ) {
    if ( colSpan < 2 ) {
      // if brick spans only one column, use all the column Ys
      return this.colYs;
    }

var colGroup = [];
    // how many different places could this brick fit horizontally
    var groupCount = this.cols + 1 - colSpan;
    // for each group potential horizontal position
    for ( var i = 0; i < groupCount; i++ ) {
      colGroup[i] = this._getColGroupY( i, colSpan );
    }
    return colGroup;
  };

proto._getColGroupY = function( col, colSpan ) {
    if ( colSpan < 2 ) {
      return this.colYs[ col ];
    }
    // make an array of colY values for that one group
    var groupColYs = this.colYs.slice( col, col + colSpan );
    // and get the max value of the array
    return Math.max.apply( Math, groupColYs );
  };

// get column position based on horizontal index. #873
  proto._getHorizontalColPosition = function( colSpan, item ) {
    var col = this.horizontalColIndex % this.cols;
    var isOver = colSpan > 1 && col + colSpan > this.cols;
    // shift to next row if item can't fit on current row
    col = isOver ? 0 : col;
    // don't let zero-size items take up space
    var hasSize = item.size.outerWidth && item.size.outerHeight;
    this.horizontalColIndex = hasSize ? col + colSpan : this.horizontalColIndex;

return {
      col: col,
      y: this._getColGroupY( col, colSpan ),
    };
  };

proto._manageStamp = function( stamp ) {
    var stampSize = getSize( stamp );
    var offset = this._getElementOffset( stamp );
    // get the columns that this stamp affects
    var isOriginLeft = this._getOption('originLeft');
    var firstX = isOriginLeft ? offset.left : offset.right;
    var lastX = firstX + stampSize.outerWidth;
    var firstCol = Math.floor( firstX / this.columnWidth );
    firstCol = Math.max( 0, firstCol );
    var lastCol = Math.floor( lastX / this.columnWidth );
    // lastCol should not go over if multiple of columnWidth #425
    lastCol -= lastX % this.columnWidth ? 0 : 1;
    lastCol = Math.min( this.cols - 1, lastCol );
    // set colYs to bottom of the stamp

var isOriginTop = this._getOption('originTop');
    var stampMaxY = ( isOriginTop ? offset.top : offset.bottom ) +
      stampSize.outerHeight;
    for ( var i = firstCol; i <= lastCol; i++ ) {
      this.colYs[i] = Math.max( stampMaxY, this.colYs[i] );
    }
  };

proto._getContainerSize = function() {
    this.maxY = Math.max.apply( Math, this.colYs );
    var size = {
      height: this.maxY
    };

if ( this._getOption('fitWidth') ) {
      size.width = this._getContainerFitWidth();
    }

return size;
  };

proto._getContainerFitWidth = function() {
    var unusedCols = 0;
    // count unused columns
    var i = this.cols;
    while ( --i ) {
      if ( this.colYs[i] !== 0 ) {
        break;
      }
      unusedCols++;
    }
    // fit container to columns that have been used
    return ( this.cols - unusedCols ) * this.columnWidth - this.gutter;
  };

proto.needsResizeLayout = function() {
    var previousWidth = this.containerWidth;
    this.getContainerWidth();
    return previousWidth != this.containerWidth;
  };

return Masonry;

}));

/***/ }),
/* 1101 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _PropTypes = __webpack_require__(459);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Provider = function (_Component) {
  _inherits(Provider, _Component);

function Provider() {
    _classCallCheck(this, Provider);

return _possibleConstructorReturn(this, (Provider.__proto__ || Object.getPrototypeOf(Provider)).apply(this, arguments));
  }

_createClass(Provider, [{
    key: 'getChildContext',
    value: function getChildContext() {
      return {
        miniStore: this.props.store
      };
    }
  }, {
    key: 'render',
    value: function render() {
      return _react.Children.only(this.props.children);
    }
  }]);

return Provider;
}(_react.Component);

Provider.propTypes = {
  store: _PropTypes.storeShape.isRequired
};
Provider.childContextTypes = {
  miniStore: _PropTypes.storeShape.isRequired
};
exports.default = Provider;

/***/ }),
/* 1102 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

exports.default = connect;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _shallowequal = __webpack_require__(115);

var _shallowequal2 = _interopRequireDefault(_shallowequal);

var _hoistNonReactStatics = __webpack_require__(1104);

var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);

var _reactLifecyclesCompat = __webpack_require__(61);

var _PropTypes = __webpack_require__(459);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function getDisplayName(WrappedComponent) {
  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
}

function isStateless(Component) {
  return !Component.prototype.render;
}

var defaultMapStateToProps = function defaultMapStateToProps() {
  return {};
};

function connect(mapStateToProps) {
  var shouldSubscribe = !!mapStateToProps;
  var finnalMapStateToProps = mapStateToProps || defaultMapStateToProps;

return function wrapWithConnect(WrappedComponent) {
    var Connect = function (_Component) {
      _inherits(Connect, _Component);

_createClass(Connect, null, [{
        key: 'getDerivedStateFromProps',
        value: function getDerivedStateFromProps(props, prevState) {
          // using ownProps
          if (mapStateToProps && mapStateToProps.length === 2 && props !== prevState.props) {
            return {
              subscribed: finnalMapStateToProps(prevState.store.getState(), props),
              props: props
            };
          }
          return { props: props };
        }
      }]);

function Connect(props, context) {
        _classCallCheck(this, Connect);

var _this = _possibleConstructorReturn(this, (Connect.__proto__ || Object.getPrototypeOf(Connect)).call(this, props, context));

_this.handleChange = function () {
          if (!_this.unsubscribe) {
            return;
          }
          var nextState = finnalMapStateToProps(_this.store.getState(), _this.props);
          _this.setState({ subscribed: nextState });
        };

_this.store = context.miniStore;
        _this.state = {
          subscribed: finnalMapStateToProps(_this.store.getState(), props),
          store: _this.store,
          props: props
        };
        return _this;
      }

_createClass(Connect, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
          this.trySubscribe();
        }
      }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
          this.tryUnsubscribe();
        }
      }, {
        key: 'shouldComponentUpdate',
        value: function shouldComponentUpdate(nextProps, nextState) {
          return !(0, _shallowequal2.default)(this.props, nextProps) || !(0, _shallowequal2.default)(this.state.subscribed, nextState.subscribed);
        }
      }, {
        key: 'trySubscribe',
        value: function trySubscribe() {
          if (shouldSubscribe) {
            this.unsubscribe = this.store.subscribe(this.handleChange);
            this.handleChange();
          }
        }
      }, {
        key: 'tryUnsubscribe',
        value: function tryUnsubscribe() {
          if (this.unsubscribe) {
            this.unsubscribe();
            this.unsubscribe = null;
          }
        }
      }, {
        key: 'getWrappedInstance',
        value: function getWrappedInstance() {
          return this.wrappedInstance;
        }
      }, {
        key: 'render',
        value: function render() {
          var _this2 = this;

var props = _extends({}, this.props, this.state.subscribed, {
            store: this.store
          });

if (!isStateless(WrappedComponent)) {
            props = _extends({}, props, {
              ref: function ref(c) {
                return _this2.wrappedInstance = c;
              }
            });
          }

return _react2.default.createElement(WrappedComponent, props);
        }
      }]);

return Connect;
    }(_react.Component);

Connect.displayName = 'Connect(' + getDisplayName(WrappedComponent) + ')';
    Connect.contextTypes = {
      miniStore: _PropTypes.storeShape.isRequired
    };

(0, _reactLifecyclesCompat.polyfill)(Connect);

return (0, _hoistNonReactStatics2.default)(Connect, WrappedComponent);
  };
}

/***/ }),
/* 1103 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

exports.default = create;
function create(initialState) {
  var state = initialState;
  var listeners = [];

function setState(partial) {
    state = _extends({}, state, partial);
    for (var i = 0; i < listeners.length; i++) {
      listeners[i]();
    }
  }

function getState() {
    return state;
  }

function subscribe(listener) {
    listeners.push(listener);

return function unsubscribe() {
      var index = listeners.indexOf(listener);
      listeners.splice(index, 1);
    };
  }

return {
    setState: setState,
    getState: getState,
    subscribe: subscribe
  };
}

/***/ }),
/* 1104 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * Copyright 2015, Yahoo! Inc.
 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
 */
var REACT_STATICS = {
    childContextTypes: true,
    contextTypes: true,
    defaultProps: true,
    displayName: true,
    getDefaultProps: true,
    getDerivedStateFromProps: true,
    mixins: true,
    propTypes: true,
    type: true
};

var KNOWN_STATICS = {
    name: true,
    length: true,
    prototype: true,
    caller: true,
    callee: true,
    arguments: true,
    arity: true
};

var defineProperty = Object.defineProperty;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = getPrototypeOf && getPrototypeOf(Object);

function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
    if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components

if (objectPrototype) {
            var inheritedComponent = getPrototypeOf(sourceComponent);
            if (inheritedComponent && inheritedComponent !== objectPrototype) {
                hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
            }
        }

var keys = getOwnPropertyNames(sourceComponent);

if (getOwnPropertySymbols) {
            keys = keys.concat(getOwnPropertySymbols(sourceComponent));
        }

for (var i = 0; i < keys.length; ++i) {
            var key = keys[i];
            if (!REACT_STATICS[key] && !KNOWN_STATICS[key] && (!blacklist || !blacklist[key])) {
                var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
                try { // Avoid failures from read-only properties
                    defineProperty(targetComponent, key, descriptor);
                } catch (e) {}
            }
        }

return targetComponent;
    }

return targetComponent;
}

module.exports = hoistNonReactStatics;

/***/ }),
/* 1105 */
/***/ (function(module, exports) {

// mutationobserver-shim v0.3.3 (github.com/megawac/MutationObserver.js)
// Authors: Graeme Yeates (github.com/megawac) 
/*
 Shim for MutationObserver interface
 Author: Graeme Yeates (github.com/megawac)
 Repository: https://github.com/megawac/MutationObserver.js
 License: WTFPL V2, 2004 (wtfpl.net).
 Though credit and staring the repo will make me feel pretty, you can modify and redistribute as you please.
 Attempts to follow spec (https://www.w3.org/TR/dom/#mutation-observers) as closely as possible for native javascript
 See https://github.com/WebKit/webkit/blob/master/Source/WebCore/dom/MutationObserver.cpp for current webkit source c++ implementation
*/
window.MutationObserver||(window.MutationObserver=function(y){function z(a){this.i=[];this.m=a}function K(a){(function c(){var d=a.takeRecords();d.length&&a.m(d,a);a.h=setTimeout(c,z._period)})()}function r(a){var b={type:null,target:null,addedNodes:[],removedNodes:[],previousSibling:null,nextSibling:null,attributeName:null,attributeNamespace:null,oldValue:null},c;for(c in a)b[c]!==y&&a[c]!==y&&(b[c]=a[c]);return b}function L(a,b){var c=E(a,b);return function(d){var f=d.length;b.a&&3===a.nodeType&&
a.nodeValue!==c.a&&d.push(new r({type:"characterData",target:a,oldValue:c.a}));b.b&&c.b&&C(d,a,c.b,b.f);if(b.c||b.g)var m=M(d,a,c,b);if(m||d.length!==f)c=E(a,b)}}function N(a,b){return b.value}function O(a,b){return"style"!==b.name?b.value:a.style.cssText}function C(a,b,c,d){for(var f={},m=b.attributes,k,g,p=m.length;p--;)k=m[p],g=k.name,d&&d[g]===y||(F(b,k)!==c[g]&&a.push(r({type:"attributes",target:b,attributeName:g,oldValue:c[g],attributeNamespace:k.namespaceURI})),f[g]=!0);for(g in c)f[g]||a.push(r({target:b,
type:"attributes",attributeName:g,oldValue:c[g]}))}function M(a,b,c,d){function f(g,p,t,q,x){var A=g.length-1;x=-~((A-x)/2);for(var h,l,e;e=g.pop();)h=t[e.j],l=q[e.l],d.c&&x&&Math.abs(e.j-e.l)>=A&&(a.push(r({type:"childList",target:p,addedNodes:[h],removedNodes:[h],nextSibling:h.nextSibling,previousSibling:h.previousSibling})),x--),d.b&&l.b&&C(a,h,l.b,d.f),d.a&&3===h.nodeType&&h.nodeValue!==l.a&&a.push(r({type:"characterData",target:h,oldValue:l.a})),d.g&&m(h,l)}function m(g,p){for(var t=g.childNodes,
q=p.c,x=t.length,A=q?q.length:0,h,l,e,n,v,B=0,w=0,u=0;w<x||u<A;)n=t[w],v=(e=q[u])&&e.node,n===v?(d.b&&e.b&&C(a,n,e.b,d.f),d.a&&e.a!==y&&n.nodeValue!==e.a&&a.push(r({type:"characterData",target:n,oldValue:e.a})),l&&f(l,g,t,q,B),d.g&&(n.childNodes.length||e.c&&e.c.length)&&m(n,e),w++,u++):(k=!0,h||(h={},l=[]),n&&(h[e=G(n)]||(h[e]=!0,-1===(e=H(q,n,u,"node"))?d.c&&(a.push(r({type:"childList",target:g,addedNodes:[n],nextSibling:n.nextSibling,previousSibling:n.previousSibling})),B++):l.push({j:w,l:e})),
w++),v&&v!==t[w]&&(h[e=G(v)]||(h[e]=!0,-1===(e=H(t,v,w))?d.c&&(a.push(r({type:"childList",target:p.node,removedNodes:[v],nextSibling:q[u+1],previousSibling:q[u-1]})),B--):l.push({j:e,l:u})),u++));l&&f(l,g,t,q,B)}var k;m(b,c);return k}function E(a,b){var c=!0;return function m(f){var k={node:f};!b.a||3!==f.nodeType&&8!==f.nodeType?(b.b&&c&&1===f.nodeType&&(k.b=I(f.attributes,function(g,p){if(!b.f||b.f[p.name])g[p.name]=F(f,p);return g},{})),c&&(b.c||b.a||b.b&&b.g)&&(k.c=P(f.childNodes,m)),c=b.g):k.a=
f.nodeValue;return k}(a)}function G(a){try{return a.id||(a.mo_id=a.mo_id||J++)}catch(b){try{return a.nodeValue}catch(c){return J++}}}function P(a,b){for(var c=[],d=0;d<a.length;d++)c[d]=b(a[d],d,a);return c}function I(a,b,c){for(var d=0;d<a.length;d++)c=b(c,a[d],d,a);return c}function H(a,b,c,d){for(;c<a.length;c++)if((d?a[c][d]:a[c])===b)return c;return-1}z._period=30;z.prototype={observe:function(a,b){for(var c={b:!!(b.attributes||b.attributeFilter||b.attributeOldValue),c:!!b.childList,g:!!b.subtree,
a:!(!b.characterData&&!b.characterDataOldValue)},d=this.i,f=0;f<d.length;f++)d[f].s===a&&d.splice(f,1);b.attributeFilter&&(c.f=I(b.attributeFilter,function(m,k){m[k]=!0;return m},{}));d.push({s:a,o:L(a,c)});this.h||K(this)},takeRecords:function(){for(var a=[],b=this.i,c=0;c<b.length;c++)b[c].o(a);return a},disconnect:function(){this.i=[];clearTimeout(this.h);this.h=null}};var D=document.createElement("i");D.style.top=0;var F=(D="null"!=D.attributes.style.value)?N:O,J=1;return z}(void 0));
//# sourceMappingURL=mutationobserver.map

/***/ }),
/* 1106 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var define = __webpack_require__(130);
var callBind = __webpack_require__(243);

var implementation = __webpack_require__(460);
var getPolyfill = __webpack_require__(461);
var shim = __webpack_require__(1107);

var polyfill = callBind(getPolyfill(), Object);

define(polyfill, {
	getPolyfill: getPolyfill,
	implementation: implementation,
	shim: shim
});

module.exports = polyfill;

/***/ }),
/* 1107 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var getPolyfill = __webpack_require__(461);
var define = __webpack_require__(130);

module.exports = function shimObjectIs() {
	var polyfill = getPolyfill();
	define(Object, { is: polyfill }, {
		is: function testObjectIs() {
			return Object.is !== polyfill;
		}
	});
	return polyfill;
};

/***/ }),
/* 1108 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var keysShim;
if (!Object.keys) {
	// modified from https://github.com/es-shims/es5-shim
	var has = Object.prototype.hasOwnProperty;
	var toStr = Object.prototype.toString;
	var isArgs = __webpack_require__(463); // eslint-disable-line global-require
	var isEnumerable = Object.prototype.propertyIsEnumerable;
	var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
	var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
	var dontEnums = [
		'toString',
		'toLocaleString',
		'valueOf',
		'hasOwnProperty',
		'isPrototypeOf',
		'propertyIsEnumerable',
		'constructor'
	];
	var equalsConstructorPrototype = function (o) {
		var ctor = o.constructor;
		return ctor && ctor.prototype === o;
	};
	var excludedKeys = {
		$applicationCache: true,
		$console: true,
		$external: true,
		$frame: true,
		$frameElement: true,
		$frames: true,
		$innerHeight: true,
		$innerWidth: true,
		$onmozfullscreenchange: true,
		$onmozfullscreenerror: true,
		$outerHeight: true,
		$outerWidth: true,
		$pageXOffset: true,
		$pageYOffset: true,
		$parent: true,
		$scrollLeft: true,
		$scrollTop: true,
		$scrollX: true,
		$scrollY: true,
		$self: true,
		$webkitIndexedDB: true,
		$webkitStorageInfo: true,
		$window: true
	};
	var hasAutomationEqualityBug = (function () {
		/* global window */
		if (typeof window === 'undefined') { return false; }
		for (var k in window) {
			try {
				if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
					try {
						equalsConstructorPrototype(window[k]);
					} catch (e) {
						return true;
					}
				}
			} catch (e) {
				return true;
			}
		}
		return false;
	}());
	var equalsConstructorPrototypeIfNotBuggy = function (o) {
		/* global window */
		if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
			return equalsConstructorPrototype(o);
		}
		try {
			return equalsConstructorPrototype(o);
		} catch (e) {
			return false;
		}
	};

keysShim = function keys(object) {
		var isObject = object !== null && typeof object === 'object';
		var isFunction = toStr.call(object) === '[object Function]';
		var isArguments = isArgs(object);
		var isString = isObject && toStr.call(object) === '[object String]';
		var theKeys = [];

if (!isObject && !isFunction && !isArguments) {
			throw new TypeError('Object.keys called on a non-object');
		}

var skipProto = hasProtoEnumBug && isFunction;
		if (isString && object.length > 0 && !has.call(object, 0)) {
			for (var i = 0; i < object.length; ++i) {
				theKeys.push(String(i));
			}
		}

if (isArguments && object.length > 0) {
			for (var j = 0; j < object.length; ++j) {
				theKeys.push(String(j));
			}
		} else {
			for (var name in object) {
				if (!(skipProto && name === 'prototype') && has.call(object, name)) {
					theKeys.push(String(name));
				}
			}
		}

if (hasDontEnumBug) {
			var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);

for (var k = 0; k < dontEnums.length; ++k) {
				if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
					theKeys.push(dontEnums[k]);
				}
			}
		}
		return theKeys;
	};
}
module.exports = keysShim;

/***/ }),
/* 1109 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
 * Outlayer Item
 */

( function( window, factory ) {
  // universal module definition
  /* jshint strict: false */ /* globals define, module, require */
  if ( true ) {
    // AMD - RequireJS
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
        __webpack_require__(263),
        __webpack_require__(265)
      ], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if ( typeof module == 'object' && module.exports ) {
    // CommonJS - Browserify, Webpack
    module.exports = factory(
      require('ev-emitter'),
      require('get-size')
    );
  } else {
    // browser global
    window.Outlayer = {};
    window.Outlayer.Item = factory(
      window.EvEmitter,
      window.getSize
    );
  }

}( window, function factory( EvEmitter, getSize ) {
'use strict';

// ----- helpers ----- //

function isEmptyObj( obj ) {
  for ( var prop in obj ) {
    return false;
  }
  prop = null;
  return true;
}

// -------------------------- CSS3 support -------------------------- //

var docElemStyle = document.documentElement.style;

var transitionProperty = typeof docElemStyle.transition == 'string' ?
  'transition' : 'WebkitTransition';
var transformProperty = typeof docElemStyle.transform == 'string' ?
  'transform' : 'WebkitTransform';

var transitionEndEvent = {
  WebkitTransition: 'webkitTransitionEnd',
  transition: 'transitionend'
}[ transitionProperty ];

// cache all vendor properties that could have vendor prefix
var vendorProperties = {
  transform: transformProperty,
  transition: transitionProperty,
  transitionDuration: transitionProperty + 'Duration',
  transitionProperty: transitionProperty + 'Property',
  transitionDelay: transitionProperty + 'Delay'
};

// -------------------------- Item -------------------------- //

function Item( element, layout ) {
  if ( !element ) {
    return;
  }

this.element = element;
  // parent layout class, i.e. Masonry, Isotope, or Packery
  this.layout = layout;
  this.position = {
    x: 0,
    y: 0
  };

this._create();
}

// inherit EvEmitter
var proto = Item.prototype = Object.create( EvEmitter.prototype );
proto.constructor = Item;

proto._create = function() {
  // transition objects
  this._transn = {
    ingProperties: {},
    clean: {},
    onEnd: {}
  };

this.css({
    position: 'absolute'
  });
};

// trigger specified handler for event type
proto.handleEvent = function( event ) {
  var method = 'on' + event.type;
  if ( this[ method ] ) {
    this[ method ]( event );
  }
};

proto.getSize = function() {
  this.size = getSize( this.element );
};

/**
 * apply CSS styles to element
 * @param {Object} style
 */
proto.css = function( style ) {
  var elemStyle = this.element.style;

for ( var prop in style ) {
    // use vendor property if available
    var supportedProp = vendorProperties[ prop ] || prop;
    elemStyle[ supportedProp ] = style[ prop ];
  }
};

// measure position, and sets it
proto.getPosition = function() {
  var style = getComputedStyle( this.element );
  var isOriginLeft = this.layout._getOption('originLeft');
  var isOriginTop = this.layout._getOption('originTop');
  var xValue = style[ isOriginLeft ? 'left' : 'right' ];
  var yValue = style[ isOriginTop ? 'top' : 'bottom' ];
  var x = parseFloat( xValue );
  var y = parseFloat( yValue );
  // convert percent to pixels
  var layoutSize = this.layout.size;
  if ( xValue.indexOf('%') != -1 ) {
    x = ( x / 100 ) * layoutSize.width;
  }
  if ( yValue.indexOf('%') != -1 ) {
    y = ( y / 100 ) * layoutSize.height;
  }
  // clean up 'auto' or other non-integer values
  x = isNaN( x ) ? 0 : x;
  y = isNaN( y ) ? 0 : y;
  // remove padding from measurement
  x -= isOriginLeft ? layoutSize.paddingLeft : layoutSize.paddingRight;
  y -= isOriginTop ? layoutSize.paddingTop : layoutSize.paddingBottom;

this.position.x = x;
  this.position.y = y;
};

// set settled position, apply padding
proto.layoutPosition = function() {
  var layoutSize = this.layout.size;
  var style = {};
  var isOriginLeft = this.layout._getOption('originLeft');
  var isOriginTop = this.layout._getOption('originTop');

// x
  var xPadding = isOriginLeft ? 'paddingLeft' : 'paddingRight';
  var xProperty = isOriginLeft ? 'left' : 'right';
  var xResetProperty = isOriginLeft ? 'right' : 'left';

var x = this.position.x + layoutSize[ xPadding ];
  // set in percentage or pixels
  style[ xProperty ] = this.getXValue( x );
  // reset other property
  style[ xResetProperty ] = '';

// y
  var yPadding = isOriginTop ? 'paddingTop' : 'paddingBottom';
  var yProperty = isOriginTop ? 'top' : 'bottom';
  var yResetProperty = isOriginTop ? 'bottom' : 'top';

var y = this.position.y + layoutSize[ yPadding ];
  // set in percentage or pixels
  style[ yProperty ] = this.getYValue( y );
  // reset other property
  style[ yResetProperty ] = '';

this.css( style );
  this.emitEvent( 'layout', [ this ] );
};

proto.getXValue = function( x ) {
  var isHorizontal = this.layout._getOption('horizontal');
  return this.layout.options.percentPosition && !isHorizontal ?
    ( ( x / this.layout.size.width ) * 100 ) + '%' : x + 'px';
};

proto.getYValue = function( y ) {
  var isHorizontal = this.layout._getOption('horizontal');
  return this.layout.options.percentPosition && isHorizontal ?
    ( ( y / this.layout.size.height ) * 100 ) + '%' : y + 'px';
};

proto._transitionTo = function( x, y ) {
  this.getPosition();
  // get current x & y from top/left
  var curX = this.position.x;
  var curY = this.position.y;

var didNotMove = x == this.position.x && y == this.position.y;

// save end position
  this.setPosition( x, y );

// if did not move and not transitioning, just go to layout
  if ( didNotMove && !this.isTransitioning ) {
    this.layoutPosition();
    return;
  }

var transX = x - curX;
  var transY = y - curY;
  var transitionStyle = {};
  transitionStyle.transform = this.getTranslate( transX, transY );

this.transition({
    to: transitionStyle,
    onTransitionEnd: {
      transform: this.layoutPosition
    },
    isCleaning: true
  });
};

proto.getTranslate = function( x, y ) {
  // flip cooridinates if origin on right or bottom
  var isOriginLeft = this.layout._getOption('originLeft');
  var isOriginTop = this.layout._getOption('originTop');
  x = isOriginLeft ? x : -x;
  y = isOriginTop ? y : -y;
  return 'translate3d(' + x + 'px, ' + y + 'px, 0)';
};

// non transition + transform support
proto.goTo = function( x, y ) {
  this.setPosition( x, y );
  this.layoutPosition();
};

proto.moveTo = proto._transitionTo;

proto.setPosition = function( x, y ) {
  this.position.x = parseFloat( x );
  this.position.y = parseFloat( y );
};

// ----- transition ----- //

/**
 * @param {Object} style - CSS
 * @param {Function} onTransitionEnd
 */

// non transition, just trigger callback
proto._nonTransition = function( args ) {
  this.css( args.to );
  if ( args.isCleaning ) {
    this._removeStyles( args.to );
  }
  for ( var prop in args.onTransitionEnd ) {
    args.onTransitionEnd[ prop ].call( this );
  }
};

/**
 * proper transition
 * @param {Object} args - arguments
 *   @param {Object} to - style to transition to
 *   @param {Object} from - style to start transition from
 *   @param {Boolean} isCleaning - removes transition styles after transition
 *   @param {Function} onTransitionEnd - callback
 */
proto.transition = function( args ) {
  // redirect to nonTransition if no transition duration
  if ( !parseFloat( this.layout.options.transitionDuration ) ) {
    this._nonTransition( args );
    return;
  }

// set from styles
  if ( args.from ) {
    this.css( args.from );
    // force redraw. http://blog.alexmaccaw.com/css-transitions
    var h = this.element.offsetHeight;
    // hack for JSHint to hush about unused var
    h = null;
  }
  // enable transition
  this.enableTransition( args.to );
  // set styles that are transitioning
  this.css( args.to );

this.isTransitioning = true;

};

// dash before all cap letters, including first for
// WebkitTransform => -webkit-transform
function toDashedAll( str ) {
  return str.replace( /([A-Z])/g, function( $1 ) {
    return '-' + $1.toLowerCase();
  });
}

var transitionProps = 'opacity,' + toDashedAll( transformProperty );

proto.enableTransition = function(/* style */) {
  // HACK changing transitionProperty during a transition
  // will cause transition to jump
  if ( this.isTransitioning ) {
    return;
  }

// make `transition: foo, bar, baz` from style object
  // HACK un-comment this when enableTransition can work
  // while a transition is happening
  // var transitionValues = [];
  // for ( var prop in style ) {
  //   // dash-ify camelCased properties like WebkitTransition
  //   prop = vendorProperties[ prop ] || prop;
  //   transitionValues.push( toDashedAll( prop ) );
  // }
  // munge number to millisecond, to match stagger
  var duration = this.layout.options.transitionDuration;
  duration = typeof duration == 'number' ? duration + 'ms' : duration;
  // enable transition styles
  this.css({
    transitionProperty: transitionProps,
    transitionDuration: duration,
    transitionDelay: this.staggerDelay || 0
  });
  // listen for transition end event
  this.element.addEventListener( transitionEndEvent, this, false );
};

// ----- events ----- //

proto.onwebkitTransitionEnd = function( event ) {
  this.ontransitionend( event );
};

proto.onotransitionend = function( event ) {
  this.ontransitionend( event );
};

// properties that I munge to make my life easier
var dashedVendorProperties = {
  '-webkit-transform': 'transform'
};

proto.ontransitionend = function( event ) {
  // disregard bubbled events from children
  if ( event.target !== this.element ) {
    return;
  }
  var _transition = this._transn;
  // get property name of transitioned property, convert to prefix-free
  var propertyName = dashedVendorProperties[ event.propertyName ] || event.propertyName;

// remove property that has completed transitioning
  delete _transition.ingProperties[ propertyName ];
  // check if any properties are still transitioning
  if ( isEmptyObj( _transition.ingProperties ) ) {
    // all properties have completed transitioning
    this.disableTransition();
  }
  // clean style
  if ( propertyName in _transition.clean ) {
    // clean up style
    this.element.style[ event.propertyName ] = '';
    delete _transition.clean[ propertyName ];
  }
  // trigger onTransitionEnd callback
  if ( propertyName in _transition.onEnd ) {
    var onTransitionEnd = _transition.onEnd[ propertyName ];
    onTransitionEnd.call( this );
    delete _transition.onEnd[ propertyName ];
  }

this.emitEvent( 'transitionEnd', [ this ] );
};

proto.disableTransition = function() {
  this.removeTransitionStyles();
  this.element.removeEventListener( transitionEndEvent, this, false );
  this.isTransitioning = false;
};

/**
 * removes style property from element
 * @param {Object} style
**/
proto._removeStyles = function( style ) {
  // clean up transition styles
  var cleanStyle = {};
  for ( var prop in style ) {
    cleanStyle[ prop ] = '';
  }
  this.css( cleanStyle );
};

var cleanTransitionStyle = {
  transitionProperty: '',
  transitionDuration: '',
  transitionDelay: ''
};

proto.removeTransitionStyles = function() {
  // remove transition
  this.css( cleanTransitionStyle );
};

// ----- stagger ----- //

proto.stagger = function( delay ) {
  delay = isNaN( delay ) ? 0 : delay;
  this.staggerDelay = delay + 'ms';
};

// ----- show/hide/remove ----- //

// remove element from DOM
proto.removeElem = function() {
  this.element.parentNode.removeChild( this.element );
  // remove display: none
  this.css({ display: '' });
  this.emitEvent( 'remove', [ this ] );
};

proto.remove = function() {
  // just remove element if no transition support or no transition
  if ( !transitionProperty || !parseFloat( this.layout.options.transitionDuration ) ) {
    this.removeElem();
    return;
  }

// start transition
  this.once( 'transitionEnd', function() {
    this.removeElem();
  });
  this.hide();
};

proto.reveal = function() {
  delete this.isHidden;
  // remove display: none
  this.css({ display: '' });

var options = this.layout.options;

var onTransitionEnd = {};
  var transitionEndProperty = this.getHideRevealTransitionEndProperty('visibleStyle');
  onTransitionEnd[ transitionEndProperty ] = this.onRevealTransitionEnd;

this.transition({
    from: options.hiddenStyle,
    to: options.visibleStyle,
    isCleaning: true,
    onTransitionEnd: onTransitionEnd
  });
};

proto.onRevealTransitionEnd = function() {
  // check if still visible
  // during transition, item may have been hidden
  if ( !this.isHidden ) {
    this.emitEvent('reveal');
  }
};

/**
 * get style property use for hide/reveal transition end
 * @param {String} styleProperty - hiddenStyle/visibleStyle
 * @returns {String}
 */
proto.getHideRevealTransitionEndProperty = function( styleProperty ) {
  var optionStyle = this.layout.options[ styleProperty ];
  // use opacity
  if ( optionStyle.opacity ) {
    return 'opacity';
  }
  // get first property
  for ( var prop in optionStyle ) {
    return prop;
  }
};

proto.hide = function() {
  // set flag
  this.isHidden = true;
  // remove display: none
  this.css({ display: '' });

var options = this.layout.options;

var onTransitionEnd = {};
  var transitionEndProperty = this.getHideRevealTransitionEndProperty('hiddenStyle');
  onTransitionEnd[ transitionEndProperty ] = this.onHideTransitionEnd;

this.transition({
    from: options.visibleStyle,
    to: options.hiddenStyle,
    // keep hidden stuff hidden
    isCleaning: true,
    onTransitionEnd: onTransitionEnd
  });
};

proto.onHideTransitionEnd = function() {
  // check if still hidden
  // during transition, item may have been un-hidden
  if ( this.isHidden ) {
    this.css({ display: 'none' });
    this.emitEvent('hide');
  }
};

proto.destroy = function() {
  this.css({
    position: '',
    left: '',
    right: '',
    top: '',
    bottom: '',
    transition: '',
    transform: ''
  });
};

return Item;

}));

/***/ }),
/* 1110 */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
 * Outlayer v2.1.1
 * the brains and guts of a layout library
 * MIT license
 */

( function( window, factory ) {
  'use strict';
  // universal module definition
  /* jshint strict: false */ /* globals define, module, require */
  if ( true ) {
    // AMD - RequireJS
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
        __webpack_require__(263),
        __webpack_require__(265),
        __webpack_require__(943),
        __webpack_require__(1109)
      ], __WEBPACK_AMD_DEFINE_RESULT__ = function( EvEmitter, getSize, utils, Item ) {
        return factory( window, EvEmitter, getSize, utils, Item);
      }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else if ( typeof module == 'object' && module.exports ) {
    // CommonJS - Browserify, Webpack
    module.exports = factory(
      window,
      require('ev-emitter'),
      require('get-size'),
      require('fizzy-ui-utils'),
      require('./item')
    );
  } else {
    // browser global
    window.Outlayer = factory(
      window,
      window.EvEmitter,
      window.getSize,
      window.fizzyUIUtils,
      window.Outlayer.Item
    );
  }

}( window, function factory( window, EvEmitter, getSize, utils, Item ) {
'use strict';

// ----- vars ----- //

var console = window.console;
var jQuery = window.jQuery;
var noop = function() {};

// -------------------------- Outlayer -------------------------- //

// globally unique identifiers
var GUID = 0;
// internal store of all Outlayer intances
var instances = {};

/**
 * @param {Element, String} element
 * @param {Object} options
 * @constructor
 */
function Outlayer( element, options ) {
  var queryElement = utils.getQueryElement( element );
  if ( !queryElement ) {
    if ( console ) {
      console.error( 'Bad element for ' + this.constructor.namespace +
        ': ' + ( queryElement || element ) );
    }
    return;
  }
  this.element = queryElement;
  // add jQuery
  if ( jQuery ) {
    this.$element = jQuery( this.element );
  }

// options
  this.options = utils.extend( {}, this.constructor.defaults );
  this.option( options );

// add id for Outlayer.getFromElement
  var id = ++GUID;
  this.element.outlayerGUID = id; // expando
  instances[ id ] = this; // associate via id

// kick it off
  this._create();

var isInitLayout = this._getOption('initLayout');
  if ( isInitLayout ) {
    this.layout();
  }
}

// settings are for internal use only
Outlayer.namespace = 'outlayer';
Outlayer.Item = Item;

// default options
Outlayer.defaults = {
  containerStyle: {
    position: 'relative'
  },
  initLayout: true,
  originLeft: true,
  originTop: true,
  resize: true,
  resizeContainer: true,
  // item options
  transitionDuration: '0.4s',
  hiddenStyle: {
    opacity: 0,
    transform: 'scale(0.001)'
  },
  visibleStyle: {
    opacity: 1,
    transform: 'scale(1)'
  }
};

var proto = Outlayer.prototype;
// inherit EvEmitter
utils.extend( proto, EvEmitter.prototype );

/**
 * set options
 * @param {Object} opts
 */
proto.option = function( opts ) {
  utils.extend( this.options, opts );
};

/**
 * get backwards compatible option value, check old name
 */
proto._getOption = function( option ) {
  var oldOption = this.constructor.compatOptions[ option ];
  return oldOption && this.options[ oldOption ] !== undefined ?
    this.options[ oldOption ] : this.options[ option ];
};

Outlayer.compatOptions = {
  // currentName: oldName
  initLayout: 'isInitLayout',
  horizontal: 'isHorizontal',
  layoutInstant: 'isLayoutInstant',
  originLeft: 'isOriginLeft',
  originTop: 'isOriginTop',
  resize: 'isResizeBound',
  resizeContainer: 'isResizingContainer'
};

proto._create = function() {
  // get items from children
  this.reloadItems();
  // elements that affect layout, but are not laid out
  this.stamps = [];
  this.stamp( this.options.stamp );
  // set container style
  utils.extend( this.element.style, this.options.containerStyle );

// bind resize method
  var canBindResize = this._getOption('resize');
  if ( canBindResize ) {
    this.bindResize();
  }
};

// goes through all children again and gets bricks in proper order
proto.reloadItems = function() {
  // collection of item elements
  this.items = this._itemize( this.element.children );
};

/**
 * turn elements into Outlayer.Items to be used in layout
 * @param {Array or NodeList or HTMLElement} elems
 * @returns {Array} items - collection of new Outlayer Items
 */
proto._itemize = function( elems ) {

var itemElems = this._filterFindItemElements( elems );
  var Item = this.constructor.Item;

// create new Outlayer Items for collection
  var items = [];
  for ( var i=0; i < itemElems.length; i++ ) {
    var elem = itemElems[i];
    var item = new Item( elem, this );
    items.push( item );
  }

return items;
};

/**
 * get item elements to be used in layout
 * @param {Array or NodeList or HTMLElement} elems
 * @returns {Array} items - item elements
 */
proto._filterFindItemElements = function( elems ) {
  return utils.filterFindElements( elems, this.options.itemSelector );
};

/**
 * getter method for getting item elements
 * @returns {Array} elems - collection of item elements
 */
proto.getItemElements = function() {
  return this.items.map( function( item ) {
    return item.element;
  });
};

// ----- init & layout ----- //

/**
 * lays out all items
 */
proto.layout = function() {
  this._resetLayout();
  this._manageStamps();

// don't animate first layout
  var layoutInstant = this._getOption('layoutInstant');
  var isInstant = layoutInstant !== undefined ?
    layoutInstant : !this._isLayoutInited;
  this.layoutItems( this.items, isInstant );

// flag for initalized
  this._isLayoutInited = true;
};

// _init is alias for layout
proto._init = proto.layout;

/**
 * logic before any new layout
 */
proto._resetLayout = function() {
  this.getSize();
};

proto.getSize = function() {
  this.size = getSize( this.element );
};

/**
 * get measurement from option, for columnWidth, rowHeight, gutter
 * if option is String -> get element from selector string, & get size of element
 * if option is Element -> get size of element
 * else use option as a number
 *
 * @param {String} measurement
 * @param {String} size - width or height
 * @private
 */
proto._getMeasurement = function( measurement, size ) {
  var option = this.options[ measurement ];
  var elem;
  if ( !option ) {
    // default to 0
    this[ measurement ] = 0;
  } else {
    // use option as an element
    if ( typeof option == 'string' ) {
      elem = this.element.querySelector( option );
    } else if ( option instanceof HTMLElement ) {
      elem = option;
    }
    // use size of element, if element
    this[ measurement ] = elem ? getSize( elem )[ size ] : option;
  }
};

/**
 * layout a collection of item elements
 * @api public
 */
proto.layoutItems = function( items, isInstant ) {
  items = this._getItemsForLayout( items );

this._layoutItems( items, isInstant );

this._postLayout();
};

/**
 * get the items to be laid out
 * you may want to skip over some items
 * @param {Array} items
 * @returns {Array} items
 */
proto._getItemsForLayout = function( items ) {
  return items.filter( function( item ) {
    return !item.isIgnored;
  });
};

/**
 * layout items
 * @param {Array} items
 * @param {Boolean} isInstant
 */
proto._layoutItems = function( items, isInstant ) {
  this._emitCompleteOnItems( 'layout', items );

if ( !items || !items.length ) {
    // no items, emit event with empty array
    return;
  }

var queue = [];

items.forEach( function( item ) {
    // get x/y object from method
    var position = this._getItemLayoutPosition( item );
    // enqueue
    position.item = item;
    position.isInstant = isInstant || item.isLayoutInstant;
    queue.push( position );
  }, this );

this._processLayoutQueue( queue );
};

/**
 * get item layout position
 * @param {Outlayer.Item} item
 * @returns {Object} x and y position
 */
proto._getItemLayoutPosition = function( /* item */ ) {
  return {
    x: 0,
    y: 0
  };
};

/**
 * iterate over array and position each item
 * Reason being - separating this logic prevents 'layout invalidation'
 * thx @paul_irish
 * @param {Array} queue
 */
proto._processLayoutQueue = function( queue ) {
  this.updateStagger();
  queue.forEach( function( obj, i ) {
    this._positionItem( obj.item, obj.x, obj.y, obj.isInstant, i );
  }, this );
};

// set stagger from option in milliseconds number
proto.updateStagger = function() {
  var stagger = this.options.stagger;
  if ( stagger === null || stagger === undefined ) {
    this.stagger = 0;
    return;
  }
  this.stagger = getMilliseconds( stagger );
  return this.stagger;
};

/**
 * Sets position of item in DOM
 * @param {Outlayer.Item} item
 * @param {Number} x - horizontal position
 * @param {Number} y - vertical position
 * @param {Boolean} isInstant - disables transitions
 */
proto._positionItem = function( item, x, y, isInstant, i ) {
  if ( isInstant ) {
    // if not transition, just set CSS
    item.goTo( x, y );
  } else {
    item.stagger( i * this.stagger );
    item.moveTo( x, y );
  }
};

/**
 * Any logic you want to do after each layout,
 * i.e. size the container
 */
proto._postLayout = function() {
  this.resizeContainer();
};

proto.resizeContainer = function() {
  var isResizingContainer = this._getOption('resizeContainer');
  if ( !isResizingContainer ) {
    return;
  }
  var size = this._getContainerSize();
  if ( size ) {
    this._setContainerMeasure( size.width, true );
    this._setContainerMeasure( size.height, false );
  }
};

/**
 * Sets width or height of container if returned
 * @returns {Object} size
 *   @param {Number} width
 *   @param {Number} height
 */
proto._getContainerSize = noop;

/**
 * @param {Number} measure - size of width or height
 * @param {Boolean} isWidth
 */
proto._setContainerMeasure = function( measure, isWidth ) {
  if ( measure === undefined ) {
    return;
  }

var elemSize = this.size;
  // add padding and border width if border box
  if ( elemSize.isBorderBox ) {
    measure += isWidth ? elemSize.paddingLeft + elemSize.paddingRight +
      elemSize.borderLeftWidth + elemSize.borderRightWidth :
      elemSize.paddingBottom + elemSize.paddingTop +
      elemSize.borderTopWidth + elemSize.borderBottomWidth;
  }

measure = Math.max( measure, 0 );
  this.element.style[ isWidth ? 'width' : 'height' ] = measure + 'px';
};

/**
 * emit eventComplete on a collection of items events
 * @param {String} eventName
 * @param {Array} items - Outlayer.Items
 */
proto._emitCompleteOnItems = function( eventName, items ) {
  var _this = this;
  function onComplete() {
    _this.dispatchEvent( eventName + 'Complete', null, [ items ] );
  }

var count = items.length;
  if ( !items || !count ) {
    onComplete();
    return;
  }

var doneCount = 0;
  function tick() {
    doneCount++;
    if ( doneCount == count ) {
      onComplete();
    }
  }

// bind callback
  items.forEach( function( item ) {
    item.once( eventName, tick );
  });
};

/**
 * emits events via EvEmitter and jQuery events
 * @param {String} type - name of event
 * @param {Event} event - original event
 * @param {Array} args - extra arguments
 */
proto.dispatchEvent = function( type, event, args ) {
  // add original event to arguments
  var emitArgs = event ? [ event ].concat( args ) : args;
  this.emitEvent( type, emitArgs );

if ( jQuery ) {
    // set this.$element
    this.$element = this.$element || jQuery( this.element );
    if ( event ) {
      // create jQuery event
      var $event = jQuery.Event( event );
      $event.type = type;
      this.$element.trigger( $event, args );
    } else {
      // just trigger with type if no event available
      this.$element.trigger( type, args );
    }
  }
};

// -------------------------- ignore & stamps -------------------------- //

/**
 * keep item in collection, but do not lay it out
 * ignored items do not get skipped in layout
 * @param {Element} elem
 */
proto.ignore = function( elem ) {
  var item = this.getItem( elem );
  if ( item ) {
    item.isIgnored = true;
  }
};

/**
 * return item to layout collection
 * @param {Element} elem
 */
proto.unignore = function( elem ) {
  var item = this.getItem( elem );
  if ( item ) {
    delete item.isIgnored;
  }
};

/**
 * adds elements to stamps
 * @param {NodeList, Array, Element, or String} elems
 */
proto.stamp = function( elems ) {
  elems = this._find( elems );
  if ( !elems ) {
    return;
  }

this.stamps = this.stamps.concat( elems );
  // ignore
  elems.forEach( this.ignore, this );
};

/**
 * removes elements to stamps
 * @param {NodeList, Array, or Element} elems
 */
proto.unstamp = function( elems ) {
  elems = this._find( elems );
  if ( !elems ){
    return;
  }

elems.forEach( function( elem ) {
    // filter out removed stamp elements
    utils.removeFrom( this.stamps, elem );
    this.unignore( elem );
  }, this );
};

/**
 * finds child elements
 * @param {NodeList, Array, Element, or String} elems
 * @returns {Array} elems
 */
proto._find = function( elems ) {
  if ( !elems ) {
    return;
  }
  // if string, use argument as selector string
  if ( typeof elems == 'string' ) {
    elems = this.element.querySelectorAll( elems );
  }
  elems = utils.makeArray( elems );
  return elems;
};

proto._manageStamps = function() {
  if ( !this.stamps || !this.stamps.length ) {
    return;
  }

this._getBoundingRect();

this.stamps.forEach( this._manageStamp, this );
};

// update boundingLeft / Top
proto._getBoundingRect = function() {
  // get bounding rect for container element
  var boundingRect = this.element.getBoundingClientRect();
  var size = this.size;
  this._boundingRect = {
    left: boundingRect.left + size.paddingLeft + size.borderLeftWidth,
    top: boundingRect.top + size.paddingTop + size.borderTopWidth,
    right: boundingRect.right - ( size.paddingRight + size.borderRightWidth ),
    bottom: boundingRect.bottom - ( size.paddingBottom + size.borderBottomWidth )
  };
};

/**
 * @param {Element} stamp
**/
proto._manageStamp = noop;

/**
 * get x/y position of element relative to container element
 * @param {Element} elem
 * @returns {Object} offset - has left, top, right, bottom
 */
proto._getElementOffset = function( elem ) {
  var boundingRect = elem.getBoundingClientRect();
  var thisRect = this._boundingRect;
  var size = getSize( elem );
  var offset = {
    left: boundingRect.left - thisRect.left - size.marginLeft,
    top: boundingRect.top - thisRect.top - size.marginTop,
    right: thisRect.right - boundingRect.right - size.marginRight,
    bottom: thisRect.bottom - boundingRect.bottom - size.marginBottom
  };
  return offset;
};

// -------------------------- resize -------------------------- //

// enable event handlers for listeners
// i.e. resize -> onresize
proto.handleEvent = utils.handleEvent;

/**
 * Bind layout to window resizing
 */
proto.bindResize = function() {
  window.addEventListener( 'resize', this );
  this.isResizeBound = true;
};

/**
 * Unbind layout to window resizing
 */
proto.unbindResize = function() {
  window.removeEventListener( 'resize', this );
  this.isResizeBound = false;
};

proto.onresize = function() {
  this.resize();
};

utils.debounceMethod( Outlayer, 'onresize', 100 );

proto.resize = function() {
  // don't trigger if size did not change
  // or if resize was unbound. See #9
  if ( !this.isResizeBound || !this.needsResizeLayout() ) {
    return;
  }

this.layout();
};

/**
 * check if layout is needed post layout
 * @returns Boolean
 */
proto.needsResizeLayout = function() {
  var size = getSize( this.element );
  // check that this.size and size are there
  // IE8 triggers resize on body size change, so they might not be
  var hasSizes = this.size && size;
  return hasSizes && size.innerWidth !== this.size.innerWidth;
};

// -------------------------- methods -------------------------- //

/**
 * add items to Outlayer instance
 * @param {Array or NodeList or Element} elems
 * @returns {Array} items - Outlayer.Items
**/
proto.addItems = function( elems ) {
  var items = this._itemize( elems );
  // add items to collection
  if ( items.length ) {
    this.items = this.items.concat( items );
  }
  return items;
};

/**
 * Layout newly-appended item elements
 * @param {Array or NodeList or Element} elems
 */
proto.appended = function( elems ) {
  var items = this.addItems( elems );
  if ( !items.length ) {
    return;
  }
  // layout and reveal just the new items
  this.layoutItems( items, true );
  this.reveal( items );
};

/**
 * Layout prepended elements
 * @param {Array or NodeList or Element} elems
 */
proto.prepended = function( elems ) {
  var items = this._itemize( elems );
  if ( !items.length ) {
    return;
  }
  // add items to beginning of collection
  var previousItems = this.items.slice(0);
  this.items = items.concat( previousItems );
  // start new layout
  this._resetLayout();
  this._manageStamps();
  // layout new stuff without transition
  this.layoutItems( items, true );
  this.reveal( items );
  // layout previous items
  this.layoutItems( previousItems );
};

/**
 * reveal a collection of items
 * @param {Array of Outlayer.Items} items
 */
proto.reveal = function( items ) {
  this._emitCompleteOnItems( 'reveal', items );
  if ( !items || !items.length ) {
    return;
  }
  var stagger = this.updateStagger();
  items.forEach( function( item, i ) {
    item.stagger( i * stagger );
    item.reveal();
  });
};

/**
 * hide a collection of items
 * @param {Array of Outlayer.Items} items
 */
proto.hide = function( items ) {
  this._emitCompleteOnItems( 'hide', items );
  if ( !items || !items.length ) {
    return;
  }
  var stagger = this.updateStagger();
  items.forEach( function( item, i ) {
    item.stagger( i * stagger );
    item.hide();
  });
};

/**
 * reveal item elements
 * @param {Array}, {Element}, {NodeList} items
 */
proto.revealItemElements = function( elems ) {
  var items = this.getItems( elems );
  this.reveal( items );
};

/**
 * hide item elements
 * @param {Array}, {Element}, {NodeList} items
 */
proto.hideItemElements = function( elems ) {
  var items = this.getItems( elems );
  this.hide( items );
};

/**
 * get Outlayer.Item, given an Element
 * @param {Element} elem
 * @param {Function} callback
 * @returns {Outlayer.Item} item
 */
proto.getItem = function( elem ) {
  // loop through items to get the one that matches
  for ( var i=0; i < this.items.length; i++ ) {
    var item = this.items[i];
    if ( item.element == elem ) {
      // return item
      return item;
    }
  }
};

/**
 * get collection of Outlayer.Items, given Elements
 * @param {Array} elems
 * @returns {Array} items - Outlayer.Items
 */
proto.getItems = function( elems ) {
  elems = utils.makeArray( elems );
  var items = [];
  elems.forEach( function( elem ) {
    var item = this.getItem( elem );
    if ( item ) {
      items.push( item );
    }
  }, this );

return items;
};

/**
 * remove element(s) from instance and DOM
 * @param {Array or NodeList or Element} elems
 */
proto.remove = function( elems ) {
  var removeItems = this.getItems( elems );

this._emitCompleteOnItems( 'remove', removeItems );

// bail if no items to remove
  if ( !removeItems || !removeItems.length ) {
    return;
  }

removeItems.forEach( function( item ) {
    item.remove();
    // remove item from collection
    utils.removeFrom( this.items, item );
  }, this );
};

// ----- destroy ----- //

// remove and disable Outlayer instance
proto.destroy = function() {
  // clean up dynamic styles
  var style = this.element.style;
  style.height = '';
  style.position = '';
  style.width = '';
  // destroy items
  this.items.forEach( function( item ) {
    item.destroy();
  });

this.unbindResize();

var id = this.element.outlayerGUID;
  delete instances[ id ]; // remove reference to instance by id
  delete this.element.outlayerGUID;
  // remove data for jQuery
  if ( jQuery ) {
    jQuery.removeData( this.element, this.constructor.namespace );
  }

};

// -------------------------- data -------------------------- //

/**
 * get Outlayer instance from element
 * @param {Element} elem
 * @returns {Outlayer}
 */
Outlayer.data = function( elem ) {
  elem = utils.getQueryElement( elem );
  var id = elem && elem.outlayerGUID;
  return id && instances[ id ];
};

// -------------------------- create Outlayer class -------------------------- //

/**
 * create a layout class
 * @param {String} namespace
 */
Outlayer.create = function( namespace, options ) {
  // sub-class Outlayer
  var Layout = subclass( Outlayer );
  // apply new options and compatOptions
  Layout.defaults = utils.extend( {}, Outlayer.defaults );
  utils.extend( Layout.defaults, options );
  Layout.compatOptions = utils.extend( {}, Outlayer.compatOptions  );

Layout.namespace = namespace;

Layout.data = Outlayer.data;

// sub-class Item
  Layout.Item = subclass( Item );

// -------------------------- declarative -------------------------- //

utils.htmlInit( Layout, namespace );

// -------------------------- jQuery bridge -------------------------- //

// make into jQuery plugin
  if ( jQuery && jQuery.bridget ) {
    jQuery.bridget( namespace, Layout );
  }

return Layout;
};

function subclass( Parent ) {
  function SubClass() {
    Parent.apply( this, arguments );
  }

SubClass.prototype = Object.create( Parent.prototype );
  SubClass.prototype.constructor = SubClass;

return SubClass;
}

// ----- helpers ----- //

// how many milliseconds are in each unit
var msUnits = {
  ms: 1,
  s: 1000
};

// munge time-like parameter into millisecond number
// '0.4s' -> 40
function getMilliseconds( time ) {
  if ( typeof time == 'number' ) {
    return time;
  }
  var matches = time.match( /(^\d*\.?\d*)(\w*)/ );
  var num = matches && matches[1];
  var unit = matches && matches[2];
  if ( !num.length ) {
    return 0;
  }
  num = parseFloat( num );
  var mult = msUnits[ unit ] || 1;
  return num * mult;
}

// ----- fin ----- //

// back in global
Outlayer.Item = Item;

return Outlayer;

}));

/***/ }),
/* 1111 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(process) {// Generated by CoffeeScript 1.12.2
(function() {
  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;

if ((typeof performance !== "undefined" && performance !== null) && performance.now) {
    module.exports = function() {
      return performance.now();
    };
  } else if ((typeof process !== "undefined" && process !== null) && process.hrtime) {
    module.exports = function() {
      return (getNanoSeconds() - nodeLoadTime) / 1e6;
    };
    hrtime = process.hrtime;
    getNanoSeconds = function() {
      var hr;
      hr = hrtime();
      return hr[0] * 1e9 + hr[1];
    };
    moduleLoadTime = getNanoSeconds();
    upTime = process.uptime() * 1e9;
    nodeLoadTime = moduleLoadTime - upTime;
  } else if (Date.now) {
    module.exports = function() {
      return Date.now() - loadTime;
    };
    loadTime = Date.now();
  } else {
    module.exports = function() {
      return new Date().getTime() - loadTime;
    };
    loadTime = new Date().getTime();
  }

}).call(this);

//# sourceMappingURL=performance-now.js.map

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1112 */
/***/ (function(module, exports, __webpack_require__) {

var printWarning = function() {};

if (process.env.NODE_ENV !== 'production') {
  var ReactPropTypesSecret = __webpack_require__(297);
  var loggedTypeFailures = {};
  var has = __webpack_require__(464);

printWarning = function(text) {
    var message = 'Warning: ' + text;
    if (typeof console !== 'undefined') {
      console.error(message);
    }
    try {
      // --- Welcome to debugging React ---
      // This error was thrown as a convenience so that you can use this stack
      // to find the callsite that caused this warning to fire.
      throw new Error(message);
    } catch (x) { /**/ }
  };
}

/**
 * Assert that the values match with the type specs.
 * Error messages are memorized and will only be shown once.
 *
 * @param {object} typeSpecs Map of name to a ReactPropType
 * @param {object} values Runtime values that need to be type-checked
 * @param {string} location e.g. "prop", "context", "child context"
 * @param {string} componentName Name of the component for error messages.
 * @param {?Function} getStack Returns the component stack.
 * @private
 */
function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
  if (process.env.NODE_ENV !== 'production') {
    for (var typeSpecName in typeSpecs) {
      if (has(typeSpecs, typeSpecName)) {
        var error;
        // Prop type validation may throw. In case they do, we don't want to
        // fail the render phase where it didn't fail before. So we log it.
        // After these have been cleaned up, we'll let them throw.
        try {
          // This is intentionally an invariant that gets caught. It's the same
          // behavior as without this statement except with a better message.
          if (typeof typeSpecs[typeSpecName] !== 'function') {
            var err = Error(
              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
            );
            err.name = 'Invariant Violation';
            throw err;
          }
          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
        } catch (ex) {
          error = ex;
        }
        if (error && !(error instanceof Error)) {
          printWarning(
            (componentName || 'React class') + ': type specification of ' +
            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
            'You may have forgotten to pass an argument to the type checker ' +
            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
            'shape all require an argument).'
          );
        }
        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
          // Only monitor this failure once because there tends to be a lot of the
          // same error.
          loggedTypeFailures[error.message] = true;

var stack = getStack ? getStack() : '';

printWarning(
            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
          );
        }
      }
    }
  }
}

/**
 * Resets warning cache when testing.
 *
 * @private
 */
checkPropTypes.resetWarningCache = function() {
  if (process.env.NODE_ENV !== 'production') {
    loggedTypeFailures = {};
  }
}

module.exports = checkPropTypes;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1113 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

var ReactPropTypesSecret = __webpack_require__(297);

function emptyFunction() {}
function emptyFunctionWithReset() {}
emptyFunctionWithReset.resetWarningCache = emptyFunction;

module.exports = function() {
  function shim(props, propName, componentName, location, propFullName, secret) {
    if (secret === ReactPropTypesSecret) {
      // It is still safe when called from React.
      return;
    }
    var err = new Error(
      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
      'Use PropTypes.checkPropTypes() to call them. ' +
      'Read more at http://fb.me/use-check-prop-types'
    );
    err.name = 'Invariant Violation';
    throw err;
  };
  shim.isRequired = shim;
  function getShim() {
    return shim;
  };
  // Important!
  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
  var ReactPropTypes = {
    array: shim,
    bigint: shim,
    bool: shim,
    func: shim,
    number: shim,
    object: shim,
    string: shim,
    symbol: shim,

any: shim,
    arrayOf: getShim,
    element: shim,
    elementType: shim,
    instanceOf: getShim,
    node: shim,
    objectOf: getShim,
    oneOf: getShim,
    oneOfType: getShim,
    shape: getShim,
    exact: getShim,

checkPropTypes: emptyFunctionWithReset,
    resetWarningCache: emptyFunction
  };

ReactPropTypes.PropTypes = ReactPropTypes;

return ReactPropTypes;
};

/***/ }),
/* 1114 */
/***/ (function(module, exports, __webpack_require__) {

var ReactIs = __webpack_require__(306);
var assign = __webpack_require__(24);

var ReactPropTypesSecret = __webpack_require__(297);
var has = __webpack_require__(464);
var checkPropTypes = __webpack_require__(1112);

var printWarning = function() {};

if (process.env.NODE_ENV !== 'production') {
  printWarning = function(text) {
    var message = 'Warning: ' + text;
    if (typeof console !== 'undefined') {
      console.error(message);
    }
    try {
      // --- Welcome to debugging React ---
      // This error was thrown as a convenience so that you can use this stack
      // to find the callsite that caused this warning to fire.
      throw new Error(message);
    } catch (x) {}
  };
}

function emptyFunctionThatReturnsNull() {
  return null;
}

module.exports = function(isValidElement, throwOnDirectAccess) {
  /* global Symbol */
  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.

/**
   * Returns the iterator method function contained on the iterable object.
   *
   * Be sure to invoke the function with the iterable as context:
   *
   *     var iteratorFn = getIteratorFn(myIterable);
   *     if (iteratorFn) {
   *       var iterator = iteratorFn.call(myIterable);
   *       ...
   *     }
   *
   * @param {?object} maybeIterable
   * @return {?function}
   */
  function getIteratorFn(maybeIterable) {
    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
    if (typeof iteratorFn === 'function') {
      return iteratorFn;
    }
  }

/**
   * Collection of methods that allow declaration and validation of props that are
   * supplied to React components. Example usage:
   *
   *   var Props = require('ReactPropTypes');
   *   var MyArticle = React.createClass({
   *     propTypes: {
   *       // An optional string prop named "description".
   *       description: Props.string,
   *
   *       // A required enum prop named "category".
   *       category: Props.oneOf(['News','Photos']).isRequired,
   *
   *       // A prop named "dialog" that requires an instance of Dialog.
   *       dialog: Props.instanceOf(Dialog).isRequired
   *     },
   *     render: function() { ... }
   *   });
   *
   * A more formal specification of how these methods are used:
   *
   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
   *   decl := ReactPropTypes.{type}(.isRequired)?
   *
   * Each and every declaration produces a function with the same signature. This
   * allows the creation of custom validation functions. For example:
   *
   *  var MyLink = React.createClass({
   *    propTypes: {
   *      // An optional string or URI prop named "href".
   *      href: function(props, propName, componentName) {
   *        var propValue = props[propName];
   *        if (propValue != null && typeof propValue !== 'string' &&
   *            !(propValue instanceof URI)) {
   *          return new Error(
   *            'Expected a string or an URI for ' + propName + ' in ' +
   *            componentName
   *          );
   *        }
   *      }
   *    },
   *    render: function() {...}
   *  });
   *
   * @internal
   */

var ANONYMOUS = '<<anonymous>>';

// Important!
  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
  var ReactPropTypes = {
    array: createPrimitiveTypeChecker('array'),
    bigint: createPrimitiveTypeChecker('bigint'),
    bool: createPrimitiveTypeChecker('boolean'),
    func: createPrimitiveTypeChecker('function'),
    number: createPrimitiveTypeChecker('number'),
    object: createPrimitiveTypeChecker('object'),
    string: createPrimitiveTypeChecker('string'),
    symbol: createPrimitiveTypeChecker('symbol'),

any: createAnyTypeChecker(),
    arrayOf: createArrayOfTypeChecker,
    element: createElementTypeChecker(),
    elementType: createElementTypeTypeChecker(),
    instanceOf: createInstanceTypeChecker,
    node: createNodeChecker(),
    objectOf: createObjectOfTypeChecker,
    oneOf: createEnumTypeChecker,
    oneOfType: createUnionTypeChecker,
    shape: createShapeTypeChecker,
    exact: createStrictShapeTypeChecker,
  };

/**
   * inlined Object.is polyfill to avoid requiring consumers ship their own
   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
   */
  /*eslint-disable no-self-compare*/
  function is(x, y) {
    // SameValue algorithm
    if (x === y) {
      // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Step 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  }
  /*eslint-enable no-self-compare*/

/**
   * We use an Error-like object for backward compatibility as people may call
   * PropTypes directly and inspect their output. However, we don't use real
   * Errors anymore. We don't inspect their stack anyway, and creating them
   * is prohibitively expensive if they are created too often, such as what
   * happens in oneOfType() for any type before the one that matched.
   */
  function PropTypeError(message, data) {
    this.message = message;
    this.data = data && typeof data === 'object' ? data: {};
    this.stack = '';
  }
  // Make `instanceof Error` still work for returned errors.
  PropTypeError.prototype = Error.prototype;

function createChainableTypeChecker(validate) {
    if (process.env.NODE_ENV !== 'production') {
      var manualPropTypeCallCache = {};
      var manualPropTypeWarningCount = 0;
    }
    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
      componentName = componentName || ANONYMOUS;
      propFullName = propFullName || propName;

if (secret !== ReactPropTypesSecret) {
        if (throwOnDirectAccess) {
          // New behavior only for users of `prop-types` package
          var err = new Error(
            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
            'Use `PropTypes.checkPropTypes()` to call them. ' +
            'Read more at http://fb.me/use-check-prop-types'
          );
          err.name = 'Invariant Violation';
          throw err;
        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
          // Old behavior for people using React.PropTypes
          var cacheKey = componentName + ':' + propName;
          if (
            !manualPropTypeCallCache[cacheKey] &&
            // Avoid spamming the console because they are often not actionable except for lib authors
            manualPropTypeWarningCount < 3
          ) {
            printWarning(
              'You are manually calling a React.PropTypes validation ' +
              'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +
              'and will throw in the standalone `prop-types` package. ' +
              'You may be seeing this warning due to a third-party PropTypes ' +
              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
            );
            manualPropTypeCallCache[cacheKey] = true;
            manualPropTypeWarningCount++;
          }
        }
      }
      if (props[propName] == null) {
        if (isRequired) {
          if (props[propName] === null) {
            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
          }
          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
        }
        return null;
      } else {
        return validate(props, propName, componentName, location, propFullName);
      }
    }

var chainedCheckType = checkType.bind(null, false);
    chainedCheckType.isRequired = checkType.bind(null, true);

return chainedCheckType;
  }

function createPrimitiveTypeChecker(expectedType) {
    function validate(props, propName, componentName, location, propFullName, secret) {
      var propValue = props[propName];
      var propType = getPropType(propValue);
      if (propType !== expectedType) {
        // `propValue` being instance of, say, date/regexp, pass the 'object'
        // check, but we can offer a more precise error message here rather than
        // 'of type `object`'.
        var preciseType = getPreciseType(propValue);

return new PropTypeError(
          'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),
          {expectedType: expectedType}
        );
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

function createAnyTypeChecker() {
    return createChainableTypeChecker(emptyFunctionThatReturnsNull);
  }

function validate(props, propName, componentName, location, propFullName) {
      var propValue = props[propName];
      for (var i = 0; i < expectedValues.length; i++) {
        if (is(propValue, expectedValues[i])) {
          return null;
        }
      }

var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
        var type = getPreciseType(value);
        if (type === 'symbol') {
          return String(value);
        }
        return value;
      });
      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
    }
    return createChainableTypeChecker(validate);
  }

function createUnionTypeChecker(arrayOfTypeCheckers) {
    if (!Array.isArray(arrayOfTypeCheckers)) {
      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
      return emptyFunctionThatReturnsNull;
    }

for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
      var checker = arrayOfTypeCheckers[i];
      if (typeof checker !== 'function') {
        printWarning(
          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
        );
        return emptyFunctionThatReturnsNull;
      }
    }

function invalidValidatorError(componentName, location, propFullName, key, type) {
    return new PropTypeError(
      (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +
      'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'
    );
  }

return createChainableTypeChecker(validate);
  }

function isNode(propValue) {
    switch (typeof propValue) {
      case 'number':
      case 'string':
      case 'undefined':
        return true;
      case 'boolean':
        return !propValue;
      case 'object':
        if (Array.isArray(propValue)) {
          return propValue.every(isNode);
        }
        if (propValue === null || isValidElement(propValue)) {
          return true;
        }

return true;
      default:
        return false;
    }
  }

function isSymbol(propType, propValue) {
    // Native Symbol.
    if (propType === 'symbol') {
      return true;
    }

// falsy value can't be a Symbol
    if (!propValue) {
      return false;
    }

// 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
    if (propValue['@@toStringTag'] === 'Symbol') {
      return true;
    }

// Fallback for non-spec compliant Symbols which are polyfilled.
    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
      return true;
    }

return false;
  }

// Equivalent of `typeof` but with special handling for array and regexp.
  function getPropType(propValue) {
    var propType = typeof propValue;
    if (Array.isArray(propValue)) {
      return 'array';
    }
    if (propValue instanceof RegExp) {
      // Old webkits (at least until Android 4.0) return 'function' rather than
      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
      // passes PropTypes.object.
      return 'object';
    }
    if (isSymbol(propType, propValue)) {
      return 'symbol';
    }
    return propType;
  }

// This handles more types than `getPropType`. Only used for error messages.
  // See `createPrimitiveTypeChecker`.
  function getPreciseType(propValue) {
    if (typeof propValue === 'undefined' || propValue === null) {
      return '' + propValue;
    }
    var propType = getPropType(propValue);
    if (propType === 'object') {
      if (propValue instanceof Date) {
        return 'date';
      } else if (propValue instanceof RegExp) {
        return 'regexp';
      }
    }
    return propType;
  }

// Returns a string that is postfixed to a warning about an invalid type.
  // For example, "undefined" or "of type array"
  function getPostfixForTypeWarning(value) {
    var type = getPreciseType(value);
    switch (type) {
      case 'array':
      case 'object':
        return 'an ' + type;
      case 'boolean':
      case 'date':
      case 'regexp':
        return 'a ' + type;
      default:
        return type;
    }
  }

// Returns class name of the object, if any.
  function getClassName(propValue) {
    if (!propValue.constructor || !propValue.constructor.name) {
      return ANONYMOUS;
    }
    return propValue.constructor.name;
  }

ReactPropTypes.checkPropTypes = checkPropTypes;
  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
  ReactPropTypes.PropTypes = ReactPropTypes;

return ReactPropTypes;
};

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1115 */
/***/ (function(module, exports) {

function hsl2rgb(hsl) {
  var h = hsl[0] / 360,
      s = hsl[1] / 100,
      l = hsl[2] / 100,
      t1, t2, t3, rgb, val;

if (s == 0) {
    val = l * 255;
    return [val, val, val];
  }

if (l < 0.5)
    t2 = l * (1 + s);
  else
    t2 = l + s - l * s;
  t1 = 2 * l - t2;

rgb = [0, 0, 0];
  for (var i = 0; i < 3; i++) {
    t3 = h + 1 / 3 * - (i - 1);
    t3 < 0 && t3++;
    t3 > 1 && t3--;

if (6 * t3 < 1)
      val = t1 + (t2 - t1) * 6 * t3;
    else if (2 * t3 < 1)
      val = t2;
    else if (3 * t3 < 2)
      val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
    else
      val = t1;

rgb[i] = val * 255;
  }

return rgb;
}

module.exports = hsl2rgb;

/***/ }),
/* 1116 */
/***/ (function(module, exports) {

function hsv2rgb(hsv) {
  var h = hsv[0] / 60,
      s = hsv[1] / 100,
      v = hsv[2] / 100,
      hi = Math.floor(h) % 6;

var f = h - Math.floor(h),
      p = 255 * v * (1 - s),
      q = 255 * v * (1 - (s * f)),
      t = 255 * v * (1 - (s * (1 - f))),
      v = 255 * v;

switch(hi) {
    case 0:
      return [v, t, p];
    case 1:
      return [q, v, p];
    case 2:
      return [p, v, t];
    case 3:
      return [p, q, v];
    case 4:
      return [t, p, v];
    case 5:
      return [v, p, q];
  }
}

module.exports = hsv2rgb;

/***/ }),
/* 1117 */
/***/ (function(module, exports) {

function rgb2grayscale (rgb) {
  return (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1000;
}

module.exports = rgb2grayscale;

/***/ }),
/* 1118 */
/***/ (function(module, exports) {

function rgb2hsv(rgb) {
  var r = rgb[0],
      g = rgb[1],
      b = rgb[2],
      min = Math.min(r, g, b),
      max = Math.max(r, g, b),
      delta = max - min,
      h, s, v;

if (max == 0)
    s = 0;
  else
    s = (delta/max * 1000)/10;

if (max == min)
    h = 0;
  else if (r == max)
    h = (g - b) / delta;
  else if (g == max)
    h = 2 + (b - r) / delta;
  else if (b == max)
    h = 4 + (r - g) / delta;

h = Math.min(h * 60, 360);

if (h < 0)
    h += 360;

v = ((max / 255) * 1000) / 10;

return [h, s, v];
}

module.exports = rgb2hsv;

/***/ }),
/* 1119 */
/***/ (function(module, exports) {

function rgb2string(rgb) {
  var scheme = "rgb";

if(rgb.length === 4) {
    scheme += "a";
  }

rgb[0] = Math.round(rgb[0]);
  rgb[1] = Math.round(rgb[1]);
  rgb[2] = Math.round(rgb[2]);

return scheme + "(" + rgb.join(",") + ")";
}

module.exports = rgb2string;

/***/ }),
/* 1120 */
/***/ (function(module, exports) {

function expand(hex) {
  var result = "#";

for (var i = 1; i < hex.length; i++) {
    var val = hex.charAt(i);
    result += val + val;
  }

return result;
}

function hex(hex) {
  // #RGB or #RGBA
  if(hex.length === 4 || hex.length === 5) {
    hex = expand(hex);
  }

var rgb = [
    parseInt(hex.substring(1,3), 16),
    parseInt(hex.substring(3,5), 16),
    parseInt(hex.substring(5,7), 16)
  ];

// #RRGGBBAA
  if (hex.length === 9) {
    var alpha = parseFloat((parseInt(hex.substring(7,9), 16) / 255).toFixed(2));
    rgb.push(alpha);
  }

return rgb;
}

module.exports = hex;

/***/ }),
/* 1121 */
/***/ (function(module, exports, __webpack_require__) {

var extractComponents = __webpack_require__(465);
var clamp = __webpack_require__(466);

function parseHslComponent(component, i) {
  component = parseFloat(component);

switch(i) {
    case 0:
      return clamp(component, 0, 360);
    case 1:
    case 2:
      return clamp(component, 0, 100);
    case 3:
      return clamp(component, 0, 1);
  }
}

function hsl(color) {
  return extractComponents(color).map(parseHslComponent);
}

module.exports = hsl;

/***/ }),
/* 1122 */
/***/ (function(module, exports, __webpack_require__) {

var hsl = __webpack_require__(1121);
var hex = __webpack_require__(1120);
var rgb = __webpack_require__(1123);
var hsl2rgb = __webpack_require__(1115);

function hsl2rgbParse(color) {
  var h = hsl(color);
  var r = hsl2rgb(h);

// handle alpha since hsl2rgb doesn't know (or care!) about it
  if(h.length === 4) {
    r.push(h[3]);
  }

return r;
}

var space2parser = {
  "#" : hex,
  "hsl" : hsl2rgbParse,
  "rgb" : rgb
};

function parse(color) {
  for(var scheme in space2parser) {
    if(color.indexOf(scheme) === 0) {
      return space2parser[scheme](color);
    }
  }
}

parse.rgb = rgb;
parse.hsl = hsl;
parse.hex = hex;

module.exports = parse;

/***/ }),
/* 1123 */
/***/ (function(module, exports, __webpack_require__) {

var extractComponents = __webpack_require__(465);
var clamp = __webpack_require__(466);

function rgb(color) {
  return extractComponents(color).map(parseRgbComponent);
}

module.exports = rgb;

/***/ }),
/* 1124 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_dom_align__ = __webpack_require__(863);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_util_es_Dom_addEventListener__ = __webpack_require__(141);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__util__ = __webpack_require__(1126);

function getElement(func) {
  if (typeof func !== 'function' || !func) return null;
  return func();
}

function getPoint(point) {
  if (typeof point !== 'object' || !point) return null;
  return point;
}

var Align = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(Align, _Component);

function Align() {
    var _ref;

var _temp, _this, _ret;

__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default()(this, Align);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

return _ret = (_temp = (_this = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, (_ref = Align.__proto__ || Object.getPrototypeOf(Align)).call.apply(_ref, [this].concat(args))), _this), _this.forceAlign = function () {
      var _this$props = _this.props,
          disabled = _this$props.disabled,
          target = _this$props.target,
          align = _this$props.align,
          onAlign = _this$props.onAlign;

if (!disabled && target) {
        var source = __WEBPACK_IMPORTED_MODULE_6_react_dom___default.a.findDOMNode(_this);

var result = void 0;
        var element = getElement(target);
        var point = getPoint(target);

// IE lose focus after element realign
        // We should record activeElement and restore later
        var activeElement = document.activeElement;

if (element) {
          result = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7_dom_align__["a" /* alignElement */])(source, element, align);
        } else if (point) {
          result = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7_dom_align__["b" /* alignPoint */])(source, point, align);
        }

__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["a" /* restoreFocus */])(activeElement, source);

if (onAlign) {
          onAlign(source, result);
        }
      }
    }, _temp), __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(_this, _ret);
  }

__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass___default()(Align, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      var props = this.props;
      // if parent ref not attached .... use document.getElementById
      this.forceAlign();
      if (!props.disabled && props.monitorWindowResize) {
        this.startMonitorWindowResize();
      }
    }
  }, {
    key: 'componentDidUpdate',
    value: function componentDidUpdate(prevProps) {
      var reAlign = false;
      var props = this.props;

if (!props.disabled) {
        var source = __WEBPACK_IMPORTED_MODULE_6_react_dom___default.a.findDOMNode(this);
        var sourceRect = source ? source.getBoundingClientRect() : null;

if (prevProps.disabled) {
          reAlign = true;
        } else {
          var lastElement = getElement(prevProps.target);
          var currentElement = getElement(props.target);
          var lastPoint = getPoint(prevProps.target);
          var currentPoint = getPoint(props.target);

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["b" /* isWindow */])(lastElement) && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["b" /* isWindow */])(currentElement)) {
            // Skip if is window
            reAlign = false;
          } else if (lastElement !== currentElement || // Element change
          lastElement && !currentElement && currentPoint || // Change from element to point
          lastPoint && currentPoint && currentElement || // Change from point to element
          currentPoint && !__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["c" /* isSamePoint */])(lastPoint, currentPoint)) {
            reAlign = true;
          }

// If source element size changed
          var preRect = this.sourceRect || {};
          if (!reAlign && source && (!__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["d" /* isSimilarValue */])(preRect.width, sourceRect.width) || !__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["d" /* isSimilarValue */])(preRect.height, sourceRect.height))) {
            reAlign = true;
          }
        }

this.sourceRect = sourceRect;
      }

if (reAlign) {
        this.forceAlign();
      }

if (props.monitorWindowResize && !props.disabled) {
        this.startMonitorWindowResize();
      } else {
        this.stopMonitorWindowResize();
      }
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this.stopMonitorWindowResize();
    }
  }, {
    key: 'startMonitorWindowResize',
    value: function startMonitorWindowResize() {
      if (!this.resizeHandler) {
        this.bufferMonitor = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__util__["e" /* buffer */])(this.forceAlign, this.props.monitorBufferTime);
        this.resizeHandler = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8_rc_util_es_Dom_addEventListener__["a" /* default */])(window, 'resize', this.bufferMonitor);
      }
    }
  }, {
    key: 'stopMonitorWindowResize',
    value: function stopMonitorWindowResize() {
      if (this.resizeHandler) {
        this.bufferMonitor.clear();
        this.resizeHandler.remove();
        this.resizeHandler = null;
      }
    }
  }, {
    key: 'render',
    value: function render() {
      var _this2 = this;

var _props = this.props,
          childrenProps = _props.childrenProps,
          children = _props.children;

var child = __WEBPACK_IMPORTED_MODULE_4_react___default.a.Children.only(children);
      if (childrenProps) {
        var newProps = {};
        var propList = Object.keys(childrenProps);
        propList.forEach(function (prop) {
          newProps[prop] = _this2.props[childrenProps[prop]];
        });

return __WEBPACK_IMPORTED_MODULE_4_react___default.a.cloneElement(child, newProps);
      }
      return child;
    }
  }]);

return Align;
}(__WEBPACK_IMPORTED_MODULE_4_react__["Component"]);

Align.propTypes = {
  childrenProps: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.object,
  align: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.object.isRequired,
  target: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.shape({
    clientX: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
    clientY: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
    pageX: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
    pageY: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number
  })]),
  onAlign: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  monitorBufferTime: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
  monitorWindowResize: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  disabled: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  children: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.any
};
Align.defaultProps = {
  target: function target() {
    return window;
  },
  monitorBufferTime: 50,
  monitorWindowResize: false,
  disabled: false
};

/* harmony default export */ __webpack_exports__["a"] = (Align);

/***/ }),
/* 1125 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Align__ = __webpack_require__(1124);
// export this package's api

/* harmony default export */ __webpack_exports__["a"] = (__WEBPACK_IMPORTED_MODULE_0__Align__["a" /* default */]);

/***/ }),
/* 1126 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["e"] = buffer;
/* harmony export (immutable) */ __webpack_exports__["c"] = isSamePoint;
/* harmony export (immutable) */ __webpack_exports__["b"] = isWindow;
/* harmony export (immutable) */ __webpack_exports__["d"] = isSimilarValue;
/* harmony export (immutable) */ __webpack_exports__["a"] = restoreFocus;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_rc_util_es_Dom_contains__ = __webpack_require__(302);

function buffer(fn, ms) {
  var timer = void 0;

function clear() {
    if (timer) {
      clearTimeout(timer);
      timer = null;
    }
  }

function bufferFn() {
    clear();
    timer = setTimeout(fn, ms);
  }

bufferFn.clear = clear;

return bufferFn;
}

function isSamePoint(prev, next) {
  if (prev === next) return true;
  if (!prev || !next) return false;

if ('pageX' in next && 'pageY' in next) {
    return prev.pageX === next.pageX && prev.pageY === next.pageY;
  }

if ('clientX' in next && 'clientY' in next) {
    return prev.clientX === next.clientX && prev.clientY === next.clientY;
  }

return false;
}

function isWindow(obj) {
  return obj && typeof obj === 'object' && obj.window === obj;
}

function isSimilarValue(val1, val2) {
  var int1 = Math.floor(val1);
  var int2 = Math.floor(val2);
  return Math.abs(int1 - int2) <= 1;
}

function restoreFocus(activeElement, container) {
  // Focus back if is in the container
  if (activeElement !== document.activeElement && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_rc_util_es_Dom_contains__["a" /* default */])(container, activeElement)) {
    activeElement.focus();
  }
}

/***/ }),
/* 1127 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_css_animation__ = __webpack_require__(260);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__util_animate__ = __webpack_require__(467);

var transitionMap = {
  enter: 'transitionEnter',
  appear: 'transitionAppear',
  leave: 'transitionLeave'
};

var AnimateChild = function (_React$Component) {
  __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(AnimateChild, _React$Component);

function AnimateChild() {
    __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default()(this, AnimateChild);

return __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, (AnimateChild.__proto__ || Object.getPrototypeOf(AnimateChild)).apply(this, arguments));
  }

__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_createClass___default()(AnimateChild, [{
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this.stop();
    }
  }, {
    key: 'componentWillEnter',
    value: function componentWillEnter(done) {
      if (__WEBPACK_IMPORTED_MODULE_8__util_animate__["a" /* default */].isEnterSupported(this.props)) {
        this.transition('enter', done);
      } else {
        done();
      }
    }
  }, {
    key: 'componentWillAppear',
    value: function componentWillAppear(done) {
      if (__WEBPACK_IMPORTED_MODULE_8__util_animate__["a" /* default */].isAppearSupported(this.props)) {
        this.transition('appear', done);
      } else {
        done();
      }
    }
  }, {
    key: 'componentWillLeave',
    value: function componentWillLeave(done) {
      if (__WEBPACK_IMPORTED_MODULE_8__util_animate__["a" /* default */].isLeaveSupported(this.props)) {
        this.transition('leave', done);
      } else {
        // always sync, do not interupt with react component life cycle
        // update hidden -> animate hidden ->
        // didUpdate -> animate leave -> unmount (if animate is none)
        done();
      }
    }
  }, {
    key: 'transition',
    value: function transition(animationType, finishCallback) {
      var _this2 = this;

return AnimateChild;
}(__WEBPACK_IMPORTED_MODULE_4_react___default.a.Component);

AnimateChild.propTypes = {
  children: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.any,
  animation: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.any,
  transitionName: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.any
};
/* harmony default export */ __webpack_exports__["a"] = (AnimateChild);

/***/ }),
/* 1128 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = toArrayChildren;
/* harmony export (immutable) */ __webpack_exports__["b"] = findChildInChildrenByKey;
/* harmony export (immutable) */ __webpack_exports__["d"] = findShownChildInChildrenByKey;
/* unused harmony export findHiddenChildInChildrenByKey */
/* harmony export (immutable) */ __webpack_exports__["e"] = isSameChildren;
/* harmony export (immutable) */ __webpack_exports__["c"] = mergeChildren;
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);

function toArrayChildren(children) {
  var ret = [];
  __WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.forEach(children, function (child) {
    ret.push(child);
  });
  return ret;
}

function mergeChildren(prev, next) {
  var ret = [];

// For each key of `next`, the list of keys to insert before that key in
  // the combined list
  var nextChildrenPending = {};
  var pendingChildren = [];
  prev.forEach(function (child) {
    if (child && findChildInChildrenByKey(next, child.key)) {
      if (pendingChildren.length) {
        nextChildrenPending[child.key] = pendingChildren;
        pendingChildren = [];
      }
    } else {
      pendingChildren.push(child);
    }
  });

next.forEach(function (child) {
    if (child && Object.prototype.hasOwnProperty.call(nextChildrenPending, child.key)) {
      ret = ret.concat(nextChildrenPending[child.key]);
    }
    ret.push(child);
  });

ret = ret.concat(pendingChildren);

return ret;
}

/***/ }),
/* 1129 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony default export */ __webpack_exports__["a"] = ({
  today: 'Today',
  now: 'Now',
  backToToday: 'Back to today',
  ok: 'Ok',
  clear: 'Clear',
  month: 'Month',
  year: 'Year',
  timeSelect: 'select time',
  dateSelect: 'select date',
  weekSelect: 'Choose a week',
  monthSelect: 'Choose a month',
  yearSelect: 'Choose a year',
  decadeSelect: 'Choose a decade',
  yearFormat: 'YYYY',
  dateFormat: 'M/D/YYYY',
  dayFormat: 'D',
  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
  monthBeforeYear: true,
  previousMonth: 'Previous month (PageUp)',
  nextMonth: 'Next month (PageDown)',
  previousYear: 'Last year (Control + left)',
  nextYear: 'Next year (Control + right)',
  previousDecade: 'Last decade',
  nextDecade: 'Next decade',
  previousCentury: 'Last century',
  nextCentury: 'Next century'
});

/***/ }),
/* 1130 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties__ = __webpack_require__(54);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_react_lifecycles_compat__ = __webpack_require__(61);

var Checkbox = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(Checkbox, _Component);

function Checkbox(props) {
    __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Checkbox);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, _Component.call(this, props));

_this.handleChange = function (e) {
      var _this$props = _this.props,
          disabled = _this$props.disabled,
          onChange = _this$props.onChange;

if (disabled) {
        return;
      }
      if (!('checked' in _this.props)) {
        _this.setState({
          checked: e.target.checked
        });
      }
      if (onChange) {
        onChange({
          target: __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, _this.props, {
            checked: e.target.checked
          }),
          stopPropagation: function stopPropagation() {
            e.stopPropagation();
          },
          preventDefault: function preventDefault() {
            e.preventDefault();
          },

nativeEvent: e.nativeEvent
        });
      }
    };

_this.saveInput = function (node) {
      _this.input = node;
    };

var checked = 'checked' in props ? props.checked : props.defaultChecked;

_this.state = {
      checked: checked
    };
    return _this;
  }

Checkbox.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {
    if ('checked' in props) {
      return __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, state, {
        checked: props.checked
      });
    }
    return null;
  };

Checkbox.prototype.focus = function focus() {
    this.input.focus();
  };

Checkbox.prototype.blur = function blur() {
    this.input.blur();
  };

Checkbox.prototype.render = function render() {
    var _classNames;

var _props = this.props,
        prefixCls = _props.prefixCls,
        className = _props.className,
        style = _props.style,
        name = _props.name,
        id = _props.id,
        type = _props.type,
        disabled = _props.disabled,
        readOnly = _props.readOnly,
        tabIndex = _props.tabIndex,
        onClick = _props.onClick,
        onFocus = _props.onFocus,
        onBlur = _props.onBlur,
        autoFocus = _props.autoFocus,
        value = _props.value,
        others = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties___default()(_props, ['prefixCls', 'className', 'style', 'name', 'id', 'type', 'disabled', 'readOnly', 'tabIndex', 'onClick', 'onFocus', 'onBlur', 'autoFocus', 'value']);

var checked = this.state.checked;

var classString = __WEBPACK_IMPORTED_MODULE_7_classnames___default()(prefixCls, className, (_classNames = {}, _classNames[prefixCls + '-checked'] = checked, _classNames[prefixCls + '-disabled'] = disabled, _classNames));

return __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(
      'span',
      { className: classString, style: style },
      __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement('input', __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({
        name: name,
        id: id,
        type: type,
        readOnly: readOnly,
        disabled: disabled,
        tabIndex: tabIndex,
        className: prefixCls + '-input',
        checked: !!checked,
        onClick: onClick,
        onFocus: onFocus,
        onBlur: onBlur,
        onChange: this.handleChange,
        autoFocus: autoFocus,
        ref: this.saveInput,
        value: value
      }, globalProps)),
      __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement('span', { className: prefixCls + '-inner' })
    );
  };

return Checkbox;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

Checkbox.propTypes = {
  prefixCls: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  className: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  style: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object,
  name: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  id: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  type: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  defaultChecked: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool]),
  checked: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool]),
  disabled: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  onFocus: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onBlur: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onChange: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onClick: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  tabIndex: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number]),
  readOnly: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  autoFocus: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  value: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.any
};
Checkbox.defaultProps = {
  prefixCls: 'rc-checkbox',
  className: '',
  style: {},
  type: 'checkbox',
  defaultChecked: false,
  onFocus: function onFocus() {},
  onBlur: function onBlur() {},
  onChange: function onChange() {}
};

__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8_react_lifecycles_compat__["polyfill"])(Checkbox);

/* harmony default export */ __webpack_exports__["a"] = (Checkbox);

/***/ }),
/* 1131 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__Panel__ = __webpack_require__(1132);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__openAnimationFactory__ = __webpack_require__(1135);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_classnames__);
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function toArray(activeKey) {
  var currentActiveKey = activeKey;
  if (!Array.isArray(currentActiveKey)) {
    currentActiveKey = currentActiveKey ? [currentActiveKey] : [];
  }
  return currentActiveKey;
}

var Collapse = function (_Component) {
  _inherits(Collapse, _Component);

function Collapse(props) {
    _classCallCheck(this, Collapse);

var _this = _possibleConstructorReturn(this, (Collapse.__proto__ || Object.getPrototypeOf(Collapse)).call(this, props));

var _this$props = _this.props,
        activeKey = _this$props.activeKey,
        defaultActiveKey = _this$props.defaultActiveKey;

var currentActiveKey = defaultActiveKey;
    if ('activeKey' in _this.props) {
      currentActiveKey = activeKey;
    }

_this.state = {
      openAnimation: _this.props.openAnimation || __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3__openAnimationFactory__["a" /* default */])(_this.props.prefixCls),
      activeKey: toArray(currentActiveKey)
    };
    return _this;
  }

_createClass(Collapse, [{
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      if ('activeKey' in nextProps) {
        this.setState({
          activeKey: toArray(nextProps.activeKey)
        });
      }
      if ('openAnimation' in nextProps) {
        this.setState({
          openAnimation: nextProps.openAnimation
        });
      }
    }
  }, {
    key: 'onClickItem',
    value: function onClickItem(key) {
      var activeKey = this.state.activeKey;
      if (this.props.accordion) {
        activeKey = activeKey[0] === key ? [] : [key];
      } else {
        activeKey = [].concat(_toConsumableArray(activeKey));
        var index = activeKey.indexOf(key);
        var isActive = index > -1;
        if (isActive) {
          // remove active state
          activeKey.splice(index, 1);
        } else {
          activeKey.push(key);
        }
      }
      this.setActiveKey(activeKey);
    }
  }, {
    key: 'getItems',
    value: function getItems() {
      var _this2 = this;

var activeKey = this.state.activeKey;
      var _props = this.props,
          prefixCls = _props.prefixCls,
          accordion = _props.accordion,
          destroyInactivePanel = _props.destroyInactivePanel;

var newChildren = [];

__WEBPACK_IMPORTED_MODULE_0_react__["Children"].forEach(this.props.children, function (child, index) {
        if (!child) return;
        // If there is no key provide, use the panel order as default key
        var key = child.key || String(index);
        var _child$props = child.props,
            header = _child$props.header,
            headerClass = _child$props.headerClass,
            disabled = _child$props.disabled;

var isActive = false;
        if (accordion) {
          isActive = activeKey[0] === key;
        } else {
          isActive = activeKey.indexOf(key) > -1;
        }

var props = {
          key: key,
          header: header,
          headerClass: headerClass,
          isActive: isActive,
          prefixCls: prefixCls,
          destroyInactivePanel: destroyInactivePanel,
          openAnimation: _this2.state.openAnimation,
          accordion: accordion,
          children: child.props.children,
          onItemClick: disabled ? null : function () {
            return _this2.onClickItem(key);
          }
        };

newChildren.push(__WEBPACK_IMPORTED_MODULE_0_react___default.a.cloneElement(child, props));
      });

return newChildren;
    }
  }, {
    key: 'setActiveKey',
    value: function setActiveKey(activeKey) {
      if (!('activeKey' in this.props)) {
        this.setState({ activeKey: activeKey });
      }
      this.props.onChange(this.props.accordion ? activeKey[0] : activeKey);
    }
  }, {
    key: 'render',
    value: function render() {
      var _classNames;

var _props2 = this.props,
          prefixCls = _props2.prefixCls,
          className = _props2.className,
          style = _props2.style,
          accordion = _props2.accordion;

var collapseClassName = __WEBPACK_IMPORTED_MODULE_4_classnames___default()((_classNames = {}, _defineProperty(_classNames, prefixCls, true), _defineProperty(_classNames, className, !!className), _classNames));
      return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(
        'div',
        { className: collapseClassName, style: style, role: accordion ? 'tablist' : null },
        this.getItems()
      );
    }
  }]);

return Collapse;
}(__WEBPACK_IMPORTED_MODULE_0_react__["Component"]);

Collapse.propTypes = {
  children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.any,
  prefixCls: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
  activeKey: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string)]),
  defaultActiveKey: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string)]),
  openAnimation: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object,
  onChange: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func,
  accordion: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
  style: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object,
  destroyInactivePanel: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool
};

Collapse.defaultProps = {
  prefixCls: 'rc-collapse',
  onChange: function onChange() {},

accordion: false,
  destroyInactivePanel: false
};

Collapse.Panel = __WEBPACK_IMPORTED_MODULE_2__Panel__["a" /* default */];

/* harmony default export */ __webpack_exports__["a"] = (Collapse);

/***/ }),
/* 1132 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__PanelContent__ = __webpack_require__(1133);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rc_animate__ = __webpack_require__(139);
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var CollapsePanel = function (_Component) {
  _inherits(CollapsePanel, _Component);

function CollapsePanel() {
    var _ref;

var _temp, _this, _ret;

_classCallCheck(this, CollapsePanel);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = CollapsePanel.__proto__ || Object.getPrototypeOf(CollapsePanel)).call.apply(_ref, [this].concat(args))), _this), _this.handleItemClick = function () {
      if (_this.props.onItemClick) {
        _this.props.onItemClick();
      }
    }, _this.handleKeyPress = function (e) {
      if (e.key === 'Enter' || e.keyCode === 13 || e.which === 13) {
        _this.handleItemClick();
      }
    }, _temp), _possibleConstructorReturn(_this, _ret);
  }

_createClass(CollapsePanel, [{
    key: 'render',
    value: function render() {
      var _classNames2;

var _props = this.props,
          className = _props.className,
          id = _props.id,
          style = _props.style,
          prefixCls = _props.prefixCls,
          header = _props.header,
          headerClass = _props.headerClass,
          children = _props.children,
          isActive = _props.isActive,
          showArrow = _props.showArrow,
          destroyInactivePanel = _props.destroyInactivePanel,
          disabled = _props.disabled,
          accordion = _props.accordion,
          forceRender = _props.forceRender;

return CollapsePanel;
}(__WEBPACK_IMPORTED_MODULE_0_react__["Component"]);

CollapsePanel.propTypes = {
  className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object]),
  id: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
  children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.any,
  openAnimation: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object,
  prefixCls: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
  header: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node]),
  headerClass: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
  showArrow: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  isActive: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  onItemClick: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func,
  style: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object,
  destroyInactivePanel: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  disabled: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  accordion: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  forceRender: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool
};

CollapsePanel.defaultProps = {
  showArrow: true,
  isActive: false,
  destroyInactivePanel: false,
  onItemClick: function onItemClick() {},

headerClass: '',
  forceRender: false
};

/* harmony default export */ __webpack_exports__["a"] = (CollapsePanel);

/***/ }),
/* 1133 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__);
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var PanelContent = function (_Component) {
  _inherits(PanelContent, _Component);

function PanelContent() {
    _classCallCheck(this, PanelContent);

return _possibleConstructorReturn(this, (PanelContent.__proto__ || Object.getPrototypeOf(PanelContent)).apply(this, arguments));
  }

_createClass(PanelContent, [{
    key: 'shouldComponentUpdate',
    value: function shouldComponentUpdate(nextProps) {
      return this.props.isActive || nextProps.isActive;
    }
  }, {
    key: 'render',
    value: function render() {
      var _classnames;

this._isActived = this.props.forceRender || this._isActived || this.props.isActive;
      if (!this._isActived) {
        return null;
      }
      var _props = this.props,
          prefixCls = _props.prefixCls,
          isActive = _props.isActive,
          children = _props.children,
          destroyInactivePanel = _props.destroyInactivePanel,
          forceRender = _props.forceRender,
          role = _props.role;

return PanelContent;
}(__WEBPACK_IMPORTED_MODULE_0_react__["Component"]);

PanelContent.propTypes = {
  prefixCls: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
  isActive: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.any,
  destroyInactivePanel: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  forceRender: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
  role: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string
};

/* harmony default export */ __webpack_exports__["a"] = (PanelContent);

/***/ }),
/* 1134 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

/* harmony default export */ __webpack_exports__["default"] = (__WEBPACK_IMPORTED_MODULE_0__Collapse__["a" /* default */]);
var Panel = __WEBPACK_IMPORTED_MODULE_0__Collapse__["a" /* default */].Panel;

/***/ }),
/* 1135 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_css_animation__ = __webpack_require__(260);

/* harmony default export */ __webpack_exports__["a"] = (animation);

/***/ }),
/* 1136 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_rc_util_es_KeyCode__ = __webpack_require__(87);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rc_util_es_Dom_contains__ = __webpack_require__(302);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_animate__ = __webpack_require__(139);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__LazyRenderBox__ = __webpack_require__(1138);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_rc_util_es_getScrollBarSize__ = __webpack_require__(1165);

var Dialog = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(Dialog, _React$Component);

function Dialog() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, Dialog);

var _this = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, _React$Component.apply(this, arguments));

_this.onAnimateLeave = function () {
            var afterClose = _this.props.afterClose;
            // need demo?
            // https://github.com/react-component/dialog/pull/28

if (_this.wrap) {
                _this.wrap.style.display = 'none';
            }
            _this.inTransition = false;
            _this.removeScrollingEffect();
            if (afterClose) {
                afterClose();
            }
        };
        _this.onMaskClick = function (e) {
            // android trigger click on open (fastclick??)
            if (Date.now() - _this.openTime < 300) {
                return;
            }
            if (e.target === e.currentTarget) {
                _this.close(e);
            }
        };
        _this.onKeyDown = function (e) {
            var props = _this.props;
            if (props.keyboard && e.keyCode === __WEBPACK_IMPORTED_MODULE_6_rc_util_es_KeyCode__["a" /* default */].ESC) {
                e.stopPropagation();
                _this.close(e);
                return;
            }
            // keep focus inside dialog
            if (props.visible) {
                if (e.keyCode === __WEBPACK_IMPORTED_MODULE_6_rc_util_es_KeyCode__["a" /* default */].TAB) {
                    var activeElement = document.activeElement;
                    var sentinelStart = _this.sentinelStart;
                    if (e.shiftKey) {
                        if (activeElement === sentinelStart) {
                            _this.sentinelEnd.focus();
                        }
                    } else if (activeElement === _this.sentinelEnd) {
                        sentinelStart.focus();
                    }
                }
            }
        };
        _this.getDialogElement = function () {
            var props = _this.props;
            var closable = props.closable;
            var prefixCls = props.prefixCls;
            var dest = {};
            if (props.width !== undefined) {
                dest.width = props.width;
            }
            if (props.height !== undefined) {
                dest.height = props.height;
            }
            var footer = void 0;
            if (props.footer) {
                footer = __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", { className: prefixCls + '-footer', ref: _this.saveRef('footer') }, props.footer);
            }
            var header = void 0;
            if (props.title) {
                header = __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", { className: prefixCls + '-header', ref: _this.saveRef('header') }, __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", { className: prefixCls + '-title', id: _this.titleId }, props.title));
            }
            var closer = void 0;
            if (closable) {
                closer = __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("button", { onClick: _this.close, "aria-label": "Close", className: prefixCls + '-close' }, props.closeIcon || __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("span", { className: prefixCls + '-close-x' }));
            }
            var style = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, props.style, dest);
            var sentinelStyle = { width: 0, height: 0, overflow: 'hidden' };
            var transitionName = _this.getTransitionName();
            var dialogElement = __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](__WEBPACK_IMPORTED_MODULE_9__LazyRenderBox__["a" /* default */], { key: "dialog-element", role: "document", ref: _this.saveRef('dialog'), style: style, className: prefixCls + ' ' + (props.className || ''), visible: props.visible }, __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", { tabIndex: 0, ref: _this.saveRef('sentinelStart'), style: sentinelStyle }, "sentinelStart"), __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", { className: prefixCls + '-content' }, closer, header, __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ className: prefixCls + '-body', style: props.bodyStyle, ref: _this.saveRef('body') }, props.bodyProps), props.children), footer), __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", { tabIndex: 0, ref: _this.saveRef('sentinelEnd'), style: sentinelStyle }, "sentinelEnd"));
            return __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](__WEBPACK_IMPORTED_MODULE_8_rc_animate__["a" /* default */], { key: "dialog", showProp: "visible", onLeave: _this.onAnimateLeave, transitionName: transitionName, component: "", transitionAppear: true }, props.visible || !props.destroyOnClose ? dialogElement : null);
        };
        _this.getZIndexStyle = function () {
            var style = {};
            var props = _this.props;
            if (props.zIndex !== undefined) {
                style.zIndex = props.zIndex;
            }
            return style;
        };
        _this.getWrapStyle = function () {
            return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, _this.getZIndexStyle(), _this.props.wrapStyle);
        };
        _this.getMaskStyle = function () {
            return __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, _this.getZIndexStyle(), _this.props.maskStyle);
        };
        _this.getMaskElement = function () {
            var props = _this.props;
            var maskElement = void 0;
            if (props.mask) {
                var maskTransition = _this.getMaskTransitionName();
                maskElement = __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](__WEBPACK_IMPORTED_MODULE_9__LazyRenderBox__["a" /* default */], __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ style: _this.getMaskStyle(), key: "mask", className: props.prefixCls + '-mask', hiddenClassName: props.prefixCls + '-mask-hidden', visible: props.visible }, props.maskProps));
                if (maskTransition) {
                    maskElement = __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](__WEBPACK_IMPORTED_MODULE_8_rc_animate__["a" /* default */], { key: "mask", showProp: "visible", transitionAppear: true, component: "", transitionName: maskTransition }, maskElement);
                }
            }
            return maskElement;
        };
        _this.getMaskTransitionName = function () {
            var props = _this.props;
            var transitionName = props.maskTransitionName;
            var animation = props.maskAnimation;
            if (!transitionName && animation) {
                transitionName = props.prefixCls + '-' + animation;
            }
            return transitionName;
        };
        _this.getTransitionName = function () {
            var props = _this.props;
            var transitionName = props.transitionName;
            var animation = props.animation;
            if (!transitionName && animation) {
                transitionName = props.prefixCls + '-' + animation;
            }
            return transitionName;
        };
        _this.setScrollbar = function () {
            if (_this.bodyIsOverflowing && _this.scrollbarWidth !== undefined) {
                document.body.style.paddingRight = _this.scrollbarWidth + 'px';
            }
        };
        _this.addScrollingEffect = function () {
            openCount++;
            if (openCount !== 1) {
                return;
            }
            _this.checkScrollbar();
            _this.setScrollbar();
            document.body.style.overflow = 'hidden';
            // this.adjustDialog();
        };
        _this.removeScrollingEffect = function () {
            openCount--;
            if (openCount !== 0) {
                return;
            }
            document.body.style.overflow = '';
            _this.resetScrollbar();
            // this.resetAdjustments();
        };
        _this.close = function (e) {
            var onClose = _this.props.onClose;

if (onClose) {
                onClose(e);
            }
        };
        _this.checkScrollbar = function () {
            var fullWindowWidth = window.innerWidth;
            if (!fullWindowWidth) {
                // workaround for missing window.innerWidth in IE8
                var documentElementRect = document.documentElement.getBoundingClientRect();
                fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left);
            }
            _this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth;
            if (_this.bodyIsOverflowing) {
                _this.scrollbarWidth = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_10_rc_util_es_getScrollBarSize__["a" /* default */])();
            }
        };
        _this.resetScrollbar = function () {
            document.body.style.paddingRight = '';
        };
        _this.adjustDialog = function () {
            if (_this.wrap && _this.scrollbarWidth !== undefined) {
                var modalIsOverflowing = _this.wrap.scrollHeight > document.documentElement.clientHeight;
                _this.wrap.style.paddingLeft = (!_this.bodyIsOverflowing && modalIsOverflowing ? _this.scrollbarWidth : '') + 'px';
                _this.wrap.style.paddingRight = (_this.bodyIsOverflowing && !modalIsOverflowing ? _this.scrollbarWidth : '') + 'px';
            }
        };
        _this.resetAdjustments = function () {
            if (_this.wrap) {
                _this.wrap.style.paddingLeft = _this.wrap.style.paddingLeft = '';
            }
        };
        _this.saveRef = function (name) {
            return function (node) {
                _this[name] = node;
            };
        };
        return _this;
    }

Dialog.prototype.componentWillMount = function componentWillMount() {
        this.inTransition = false;
        this.titleId = 'rcDialogTitle' + uuid++;
    };

Dialog.prototype.componentDidMount = function componentDidMount() {
        this.componentDidUpdate({});
    };

Dialog.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
        var props = this.props;
        var mousePosition = this.props.mousePosition;
        if (props.visible) {
            // first show
            if (!prevProps.visible) {
                this.openTime = Date.now();
                this.addScrollingEffect();
                this.tryFocus();
                var dialogNode = __WEBPACK_IMPORTED_MODULE_5_react_dom__["findDOMNode"](this.dialog);
                if (mousePosition) {
                    var elOffset = offset(dialogNode);
                    setTransformOrigin(dialogNode, mousePosition.x - elOffset.left + 'px ' + (mousePosition.y - elOffset.top) + 'px');
                } else {
                    setTransformOrigin(dialogNode, '');
                }
            }
        } else if (prevProps.visible) {
            this.inTransition = true;
            if (props.mask && this.lastOutSideFocusNode) {
                try {
                    this.lastOutSideFocusNode.focus();
                } catch (e) {
                    this.lastOutSideFocusNode = null;
                }
                this.lastOutSideFocusNode = null;
            }
        }
    };

Dialog.prototype.componentWillUnmount = function componentWillUnmount() {
        if (this.props.visible || this.inTransition) {
            this.removeScrollingEffect();
        }
    };

Dialog.prototype.tryFocus = function tryFocus() {
        if (!__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7_rc_util_es_Dom_contains__["a" /* default */])(this.wrap, document.activeElement)) {
            this.lastOutSideFocusNode = document.activeElement;
            this.sentinelStart.focus();
        }
    };

Dialog.prototype.render = function render() {
        var props = this.props;
        var prefixCls = props.prefixCls,
            maskClosable = props.maskClosable;

var style = this.getWrapStyle();
        // clear hide display
        // and only set display after async anim, not here for hide
        if (props.visible) {
            style.display = null;
        }
        return __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", null, this.getMaskElement(), __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ tabIndex: -1, onKeyDown: this.onKeyDown, className: prefixCls + '-wrap ' + (props.wrapClassName || ''), ref: this.saveRef('wrap'), onClick: maskClosable ? this.onMaskClick : undefined, role: "dialog", "aria-labelledby": props.title ? this.titleId : null, style: style }, props.wrapProps), this.getDialogElement()));
    };

return Dialog;
}(__WEBPACK_IMPORTED_MODULE_4_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (Dialog);

Dialog.defaultProps = {
    className: '',
    mask: true,
    visible: false,
    keyboard: true,
    closable: true,
    maskClosable: true,
    destroyOnClose: false,
    prefixCls: 'rc-dialog'
};

/***/ }),
/* 1137 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var IS_REACT_16 = 'createPortal' in __WEBPACK_IMPORTED_MODULE_5_react_dom__;

var DialogWrap = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(DialogWrap, _React$Component);

function DialogWrap() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, DialogWrap);

var _this = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, _React$Component.apply(this, arguments));

_this.saveDialog = function (node) {
            _this._component = node;
        };
        _this.getComponent = function () {
            var extra = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

return __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](__WEBPACK_IMPORTED_MODULE_6__Dialog__["a" /* default */], __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({ ref: _this.saveDialog }, _this.props, extra, { key: "dialog" }));
        };
        // fix issue #10656
        /*
        * Custom container should not be return, because in the Portal component, it will remove the
        * return container element here, if the custom container is the only child of it's component,
        * like issue #10656, It will has a conflict with removeChild method in react-dom.
        * So here should add a child (div element) to custom container.
        * */
        _this.getContainer = function () {
            var container = document.createElement('div');
            if (_this.props.getContainer) {
                _this.props.getContainer().appendChild(container);
            } else {
                document.body.appendChild(container);
            }
            return container;
        };
        return _this;
    }

DialogWrap.prototype.shouldComponentUpdate = function shouldComponentUpdate(_ref) {
        var visible = _ref.visible;

return !!(this.props.visible || visible);
    };

DialogWrap.prototype.componentWillUnmount = function componentWillUnmount() {
        if (IS_REACT_16) {
            return;
        }
        if (this.props.visible) {
            this.renderComponent({
                afterClose: this.removeContainer,
                onClose: function onClose() {},

visible: false
            });
        } else {
            this.removeContainer();
        }
    };

DialogWrap.prototype.render = function render() {
        var _this2 = this;

var visible = this.props.visible;

var portal = null;
        if (!IS_REACT_16) {
            return __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](__WEBPACK_IMPORTED_MODULE_7_rc_util_es_ContainerRender__["a" /* default */], { parent: this, visible: visible, autoDestroy: false, getComponent: this.getComponent, getContainer: this.getContainer }, function (_ref2) {
                var renderComponent = _ref2.renderComponent,
                    removeContainer = _ref2.removeContainer;

_this2.renderComponent = renderComponent;
                _this2.removeContainer = removeContainer;
                return null;
            });
        }
        if (visible || this._component) {
            portal = __WEBPACK_IMPORTED_MODULE_4_react__["createElement"](__WEBPACK_IMPORTED_MODULE_8_rc_util_es_Portal__["a" /* default */], { getContainer: this.getContainer }, this.getComponent());
        }
        return portal;
    };

return DialogWrap;
}(__WEBPACK_IMPORTED_MODULE_4_react__["Component"]);

DialogWrap.defaultProps = {
    visible: false
};
/* harmony default export */ __webpack_exports__["a"] = (DialogWrap);

/***/ }),
/* 1138 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var LazyRenderBox = function (_React$Component) {
    __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(LazyRenderBox, _React$Component);

function LazyRenderBox() {
        __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, LazyRenderBox);

return __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, _React$Component.apply(this, arguments));
    }

LazyRenderBox.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
        return !!nextProps.hiddenClassName || !!nextProps.visible;
    };

LazyRenderBox.prototype.render = function render() {
        var className = this.props.className;
        if (!!this.props.hiddenClassName && !this.props.visible) {
            className += " " + this.props.hiddenClassName;
        }
        var props = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, this.props);
        delete props.hiddenClassName;
        delete props.visible;
        props.className = className;
        return __WEBPACK_IMPORTED_MODULE_4_react__["createElement"]("div", __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, props));
    };

return LazyRenderBox;
}(__WEBPACK_IMPORTED_MODULE_4_react__["Component"]);

/* harmony default export */ __webpack_exports__["a"] = (LazyRenderBox);

/***/ }),
/* 1139 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var InputHandler = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(InputHandler, _Component);

function InputHandler() {
    __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, InputHandler);

return __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, _Component.apply(this, arguments));
  }

InputHandler.prototype.render = function render() {
    var _props = this.props,
        prefixCls = _props.prefixCls,
        disabled = _props.disabled,
        otherProps = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties___default()(_props, ['prefixCls', 'disabled']);

return __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
      __WEBPACK_IMPORTED_MODULE_6_rmc_feedback__["a" /* default */],
      {
        disabled: disabled,
        activeClassName: prefixCls + '-handler-active'
      },
      __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement('span', otherProps)
    );
  };

return InputHandler;
}(__WEBPACK_IMPORTED_MODULE_4_react__["Component"]);

InputHandler.propTypes = {
  prefixCls: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  disabled: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  onTouchStart: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  onTouchEnd: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  onMouseDown: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  onMouseUp: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  onMouseLeave: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func
};

/* harmony default export */ __webpack_exports__["a"] = (InputHandler);

/***/ }),
/* 1140 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties__ = __webpack_require__(54);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_is_negative_zero__ = __webpack_require__(958);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_is_negative_zero___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_is_negative_zero__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_rc_util_es_KeyCode__ = __webpack_require__(87);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__InputHandler__ = __webpack_require__(1139);

function noop() {}

function preventDefault(e) {
  e.preventDefault();
}

function defaultParser(input) {
  return input.replace(/[^\w\.-]+/g, '');
}

/**
 * When click and hold on a button - the speed of auto changin the value.
 */
var SPEED = 200;

/**
 * When click and hold on a button - the delay before auto changin the value.
 */
var DELAY = 600;

/**
 * Max Safe Integer -- on IE this is not available, so manually set the number in that case.
 * The reason this is used, instead of Infinity is because numbers above the MSI are unstable
 */
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;

var isValidProps = function isValidProps(value) {
  return value !== undefined && value !== null;
};

var InputNumber = function (_React$Component) {
  __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(InputNumber, _React$Component);

function InputNumber(props) {
    __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, InputNumber);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, _React$Component.call(this, props));

_initialiseProps.call(_this);

var value = void 0;
    if ('value' in props) {
      value = props.value;
    } else {
      value = props.defaultValue;
    }
    value = _this.toNumber(value);

_this.state = {
      inputValue: _this.toPrecisionAsStep(value),
      value: value,
      focused: props.autoFocus
    };
    return _this;
  }

InputNumber.prototype.componentDidMount = function componentDidMount() {
    this.componentDidUpdate();
  };

InputNumber.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
    if ('value' in nextProps && nextProps.value !== this.props.value) {
      var value = this.state.focused ? nextProps.value : this.getValidValue(nextProps.value, nextProps.min, nextProps.max);
      this.setState({
        value: value,
        inputValue: this.inputting ? value : this.toPrecisionAsStep(value)
      });
    }

// Trigger onChange when max or min change
    // https://github.com/ant-design/ant-design/issues/11574
    var nextValue = 'value' in nextProps ? nextProps.value : this.state.value;
    var _props = this.props,
        onChange = _props.onChange,
        max = _props.max,
        min = _props.min;
    // ref: null < 20 === true
    // https://github.com/ant-design/ant-design/issues/14277

if ('max' in nextProps && nextProps.max !== max && typeof nextValue === 'number' && nextValue > nextProps.max && onChange) {
      onChange(nextProps.max);
    }
    if ('min' in nextProps && nextProps.min !== min && typeof nextValue === 'number' && nextValue < nextProps.min && onChange) {
      onChange(nextProps.min);
    }
  };

InputNumber.prototype.componentDidUpdate = function componentDidUpdate() {
    // Restore cursor
    try {
      // Firefox set the input cursor after it get focused.
      // This caused that if an input didn't init with the selection,
      // set will cause cursor not correct when first focus.
      // Safari will focus input if set selection. We need skip this.
      if (this.cursorStart !== undefined && this.state.focused) {
        // In most cases, the string after cursor is stable.
        // We can move the cursor before it

if (
        // If not match full str, try to match part of str
        !this.partRestoreByAfter(this.cursorAfter) && this.state.value !== this.props.value) {
          // If not match any of then, let's just keep the position
          // TODO: Logic should not reach here, need check if happens
          var pos = this.cursorStart + 1;

// If not have last string, just position to the end
          if (!this.cursorAfter) {
            pos = this.input.value.length;
          } else if (this.lastKeyCode === __WEBPACK_IMPORTED_MODULE_9_rc_util_es_KeyCode__["a" /* default */].BACKSPACE) {
            pos = this.cursorStart - 1;
          } else if (this.lastKeyCode === __WEBPACK_IMPORTED_MODULE_9_rc_util_es_KeyCode__["a" /* default */].DELETE) {
            pos = this.cursorStart;
          }
          this.fixCaret(pos, pos);
        } else if (this.currentValue === this.input.value) {
          // Handle some special key code
          switch (this.lastKeyCode) {
            case __WEBPACK_IMPORTED_MODULE_9_rc_util_es_KeyCode__["a" /* default */].BACKSPACE:
              this.fixCaret(this.cursorStart - 1, this.cursorStart - 1);
              break;
            case __WEBPACK_IMPORTED_MODULE_9_rc_util_es_KeyCode__["a" /* default */].DELETE:
              this.fixCaret(this.cursorStart + 1, this.cursorStart + 1);
              break;
            default:
            // Do nothing
          }
        }
      }
    } catch (e) {}
    // Do nothing

// Reset last key
    this.lastKeyCode = null;

// pressingUpOrDown is true means that someone just click up or down button
    if (!this.pressingUpOrDown) {
      return;
    }
    if (this.props.focusOnUpDown && this.state.focused) {
      if (document.activeElement !== this.input) {
        this.focus();
      }
    }

this.pressingUpOrDown = false;
  };

InputNumber.prototype.componentWillUnmount = function componentWillUnmount() {
    this.stop();
  };

InputNumber.prototype.getCurrentValidValue = function getCurrentValidValue(value) {
    var val = value;
    if (val === '') {
      val = '';
    } else if (!this.isNotCompleteNumber(parseFloat(val, 10))) {
      val = this.getValidValue(val);
    } else {
      val = this.state.value;
    }
    return this.toNumber(val);
  };

InputNumber.prototype.getRatio = function getRatio(e) {
    var ratio = 1;
    if (e.metaKey || e.ctrlKey) {
      ratio = 0.1;
    } else if (e.shiftKey) {
      ratio = 10;
    }
    return ratio;
  };

InputNumber.prototype.getValueFromEvent = function getValueFromEvent(e) {
    // optimize for chinese input expierence
    // https://github.com/ant-design/ant-design/issues/8196
    var value = e.target.value.trim().replace(/。/g, '.');

if (isValidProps(this.props.decimalSeparator)) {
      value = value.replace(this.props.decimalSeparator, '.');
    }

return value;
  };

InputNumber.prototype.getValidValue = function getValidValue(value) {
    var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.props.min;
    var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.props.max;

InputNumber.prototype.setValue = function setValue(v, callback) {
    // trigger onChange
    var newValue = this.isNotCompleteNumber(parseFloat(v, 10)) ? undefined : parseFloat(v, 10);
    var changed = newValue !== this.state.value || '' + newValue !== '' + this.state.inputValue; // https://github.com/ant-design/ant-design/issues/7363
    if (!('value' in this.props)) {
      this.setState({
        value: newValue,
        inputValue: this.toPrecisionAsStep(v)
      }, callback);
    } else {
      // always set input value same as value
      this.setState({
        inputValue: this.toPrecisionAsStep(this.state.value)
      }, callback);
    }
    if (changed) {
      this.props.onChange(newValue);
    }
  };

InputNumber.prototype.getPrecision = function getPrecision(value) {
    if (isValidProps(this.props.precision)) {
      return this.props.precision;
    }
    var valueString = value.toString();
    if (valueString.indexOf('e-') >= 0) {
      return parseInt(valueString.slice(valueString.indexOf('e-') + 2), 10);
    }
    var precision = 0;
    if (valueString.indexOf('.') >= 0) {
      precision = valueString.length - valueString.indexOf('.') - 1;
    }
    return precision;
  };

// step={1.0} value={1.51}
  // press +
  // then value should be 2.51, rather than 2.5
  // if this.props.precision is undefined
  // https://github.com/react-component/input-number/issues/39

InputNumber.prototype.getMaxPrecision = function getMaxPrecision(currentValue) {
    var ratio = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;

if (isValidProps(this.props.precision)) {
      return this.props.precision;
    }
    var step = this.props.step;

var ratioPrecision = this.getPrecision(ratio);
    var stepPrecision = this.getPrecision(step);
    var currentValuePrecision = this.getPrecision(currentValue);
    if (!currentValue) {
      return ratioPrecision + stepPrecision;
    }
    return Math.max(currentValuePrecision, ratioPrecision + stepPrecision);
  };

InputNumber.prototype.getPrecisionFactor = function getPrecisionFactor(currentValue) {
    var ratio = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;

var precision = this.getMaxPrecision(currentValue, ratio);
    return Math.pow(10, precision);
  };

InputNumber.prototype.fixCaret = function fixCaret(start, end) {
    if (start === undefined || end === undefined || !this.input || !this.input.value) {
      return;
    }

try {
      var currentStart = this.input.selectionStart;
      var currentEnd = this.input.selectionEnd;

if (start !== currentStart || end !== currentEnd) {
        this.input.setSelectionRange(start, end);
      }
    } catch (e) {
      // Fix error in Chrome:
      // Failed to read the 'selectionStart' property from 'HTMLInputElement'
      // http://stackoverflow.com/q/21177489/3040605
    }
  };

InputNumber.prototype.focus = function focus() {
    this.input.focus();
    this.recordCursorPosition();
  };

InputNumber.prototype.blur = function blur() {
    this.input.blur();
  };

InputNumber.prototype.formatWrapper = function formatWrapper(num) {
    // http://2ality.com/2012/03/signedzero.html
    // https://github.com/ant-design/ant-design/issues/9439
    if (__WEBPACK_IMPORTED_MODULE_8_is_negative_zero___default()(num)) {
      return '-0';
    }
    if (this.props.formatter) {
      return this.props.formatter(num);
    }
    return num;
  };

InputNumber.prototype.toPrecisionAsStep = function toPrecisionAsStep(num) {
    if (this.isNotCompleteNumber(num) || num === '') {
      return num;
    }
    var precision = Math.abs(this.getMaxPrecision(num));
    if (precision === 0) {
      return num.toString();
    }
    if (!isNaN(precision)) {
      return Number(num).toFixed(precision);
    }
    return num.toString();
  };

// '1.' '1x' 'xx' '' => are not complete numbers

InputNumber.prototype.isNotCompleteNumber = function isNotCompleteNumber(num) {
    return isNaN(num) || num === '' || num === null || num && num.toString().indexOf('.') === num.toString().length - 1;
  };

InputNumber.prototype.toNumber = function toNumber(num) {
    if (this.isNotCompleteNumber(num)) {
      return num;
    }
    if (isValidProps(this.props.precision)) {
      return Number(Number(num).toFixed(this.props.precision));
    }
    return Number(num);
  };

// '1.0' '1.00'  => may be a inputing number

InputNumber.prototype.toNumberWhenUserInput = function toNumberWhenUserInput(num) {
    // num.length > 16 => prevent input large number will became Infinity
    if ((/\.\d*0$/.test(num) || num.length > 16) && this.state.focused) {
      return num;
    }
    return this.toNumber(num);
  };

InputNumber.prototype.upStep = function upStep(val, rat) {
    var _props2 = this.props,
        step = _props2.step,
        min = _props2.min;

var precisionFactor = this.getPrecisionFactor(val, rat);
    var precision = Math.abs(this.getMaxPrecision(val, rat));
    var result = void 0;
    if (typeof val === 'number') {
      result = ((precisionFactor * val + precisionFactor * step * rat) / precisionFactor).toFixed(precision);
    } else {
      result = min === -Infinity ? step : min;
    }
    return this.toNumber(result);
  };

InputNumber.prototype.downStep = function downStep(val, rat) {
    var _props3 = this.props,
        step = _props3.step,
        min = _props3.min;

var precisionFactor = this.getPrecisionFactor(val, rat);
    var precision = Math.abs(this.getMaxPrecision(val, rat));
    var result = void 0;
    if (typeof val === 'number') {
      result = ((precisionFactor * val - precisionFactor * step * rat) / precisionFactor).toFixed(precision);
    } else {
      result = min === -Infinity ? -step : min;
    }
    return this.toNumber(result);
  };

InputNumber.prototype.step = function step(type, e) {
    var _this2 = this;

var ratio = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
    var recursive = arguments[3];

this.stop();
    if (e) {
      e.persist();
      e.preventDefault();
    }
    var props = this.props;
    if (props.disabled) {
      return;
    }
    var value = this.getCurrentValidValue(this.state.inputValue) || 0;
    if (this.isNotCompleteNumber(value)) {
      return;
    }
    var val = this[type + 'Step'](value, ratio);
    var outOfRange = val > props.max || val < props.min;
    if (val > props.max) {
      val = props.max;
    } else if (val < props.min) {
      val = props.min;
    }
    this.setValue(val);
    this.setState({
      focused: true
    });
    if (outOfRange) {
      return;
    }
    this.autoStepTimer = setTimeout(function () {
      _this2[type](e, ratio, true);
    }, recursive ? SPEED : DELAY);
  };

InputNumber.prototype.render = function render() {
    var _classNames;

var props = __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default()({}, this.props);

var prefixCls = props.prefixCls,
        disabled = props.disabled,
        readOnly = props.readOnly,
        useTouch = props.useTouch,
        autoComplete = props.autoComplete,
        upHandler = props.upHandler,
        downHandler = props.downHandler,
        rest = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_objectWithoutProperties___default()(props, ['prefixCls', 'disabled', 'readOnly', 'useTouch', 'autoComplete', 'upHandler', 'downHandler']);

var classes = __WEBPACK_IMPORTED_MODULE_7_classnames___default()((_classNames = {}, _classNames[prefixCls] = true, _classNames[props.className] = !!props.className, _classNames[prefixCls + '-disabled'] = disabled, _classNames[prefixCls + '-focused'] = this.state.focused, _classNames));
    var upDisabledClass = '';
    var downDisabledClass = '';
    var value = this.state.value;

if (value || value === 0) {
      if (!isNaN(value)) {
        var val = Number(value);
        if (val >= props.max) {
          upDisabledClass = prefixCls + '-handler-up-disabled';
        }
        if (val <= props.min) {
          downDisabledClass = prefixCls + '-handler-down-disabled';
        }
      } else {
        upDisabledClass = prefixCls + '-handler-up-disabled';
        downDisabledClass = prefixCls + '-handler-down-disabled';
      }
    }

var dataOrAriaAttributeProps = {};
    for (var key in props) {
      if (props.hasOwnProperty(key) && (key.substr(0, 5) === 'data-' || key.substr(0, 5) === 'aria-' || key === 'role')) {
        dataOrAriaAttributeProps[key] = props[key];
      }
    }

var editable = !props.readOnly && !props.disabled;

// focus state, show input value
    // unfocus state, show valid value
    var inputDisplayValue = this.getInputDisplayValue();

return InputNumber;
}(__WEBPACK_IMPORTED_MODULE_5_react___default.a.Component);

InputNumber.propTypes = {
  value: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string]),
  defaultValue: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string]),
  focusOnUpDown: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  autoFocus: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  onChange: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onKeyDown: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onKeyUp: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  prefixCls: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  tabIndex: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number]),
  disabled: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  onFocus: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onBlur: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  readOnly: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  max: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  min: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  step: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string]),
  upHandler: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.node,
  downHandler: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.node,
  useTouch: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  formatter: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  parser: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onMouseEnter: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onMouseLeave: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onMouseOver: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onMouseOut: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  onMouseUp: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  precision: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  required: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  pattern: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  decimalSeparator: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string
};
InputNumber.defaultProps = {
  focusOnUpDown: true,
  useTouch: false,
  prefixCls: 'rc-input-number',
  min: -MAX_SAFE_INTEGER,
  step: 1,
  style: {},
  onChange: noop,
  onKeyDown: noop,
  onFocus: noop,
  onBlur: noop,
  parser: defaultParser,
  required: false,
  autoComplete: 'off'
};

var _initialiseProps = function _initialiseProps() {
  var _this3 = this;

this.onKeyDown = function (e) {
    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }

var onKeyDown = _this3.props.onKeyDown;

if (e.keyCode === __WEBPACK_IMPORTED_MODULE_9_rc_util_es_KeyCode__["a" /* default */].UP) {
      var ratio = _this3.getRatio(e);
      _this3.up(e, ratio);
      _this3.stop();
    } else if (e.keyCode === __WEBPACK_IMPORTED_MODULE_9_rc_util_es_KeyCode__["a" /* default */].DOWN) {
      var _ratio = _this3.getRatio(e);
      _this3.down(e, _ratio);
      _this3.stop();
    }

// Trigger user key down
    _this3.recordCursorPosition();
    _this3.lastKeyCode = e.keyCode;
    if (onKeyDown) {
      onKeyDown.apply(undefined, [e].concat(args));
    }
  };

this.onKeyUp = function (e) {
    for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
      args[_key2 - 1] = arguments[_key2];
    }

var onKeyUp = _this3.props.onKeyUp;

_this3.stop();

_this3.recordCursorPosition();

// Trigger user key up
    if (onKeyUp) {
      onKeyUp.apply(undefined, [e].concat(args));
    }
  };

this.onChange = function (e) {
    if (_this3.state.focused) {
      _this3.inputting = true;
    }
    var input = _this3.props.parser(_this3.getValueFromEvent(e));
    _this3.setState({ inputValue: input });
    _this3.props.onChange(_this3.toNumberWhenUserInput(input)); // valid number or invalid string
  };

this.onMouseUp = function () {
    var onMouseUp = _this3.props.onMouseUp;

_this3.recordCursorPosition();

if (onMouseUp) {
      onMouseUp.apply(undefined, arguments);
    }
  };

this.onFocus = function () {
    var _props4;

_this3.setState({
      focused: true
    });
    (_props4 = _this3.props).onFocus.apply(_props4, arguments);
  };

this.onBlur = function (e) {
    for (var _len3 = arguments.length, args = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
      args[_key3 - 1] = arguments[_key3];
    }

_this3.inputting = false;
    _this3.setState({
      focused: false
    });
    var value = _this3.getCurrentValidValue(_this3.state.inputValue);
    e.persist(); // fix https://github.com/react-component/input-number/issues/51
    _this3.setValue(value, function () {
      var _props5;

(_props5 = _this3.props).onBlur.apply(_props5, [e].concat(args));
    });
  };

this.getInputDisplayValue = function () {
    var _state = _this3.state,
        focused = _state.focused,
        inputValue = _state.inputValue,
        value = _state.value;

var inputDisplayValue = void 0;
    if (focused) {
      inputDisplayValue = inputValue;
    } else {
      inputDisplayValue = _this3.toPrecisionAsStep(value);
    }

if (inputDisplayValue === undefined || inputDisplayValue === null) {
      inputDisplayValue = '';
    }

return inputDisplayValue;
  };

this.recordCursorPosition = function () {
    // Record position
    try {
      _this3.cursorStart = _this3.input.selectionStart;
      _this3.cursorEnd = _this3.input.selectionEnd;
      _this3.currentValue = _this3.input.value;
      _this3.cursorBefore = _this3.input.value.substring(0, _this3.cursorStart);
      _this3.cursorAfter = _this3.input.value.substring(_this3.cursorEnd);
    } catch (e) {
      // Fix error in Chrome:
      // Failed to read the 'selectionStart' property from 'HTMLInputElement'
      // http://stackoverflow.com/q/21177489/3040605
    }
  };

this.restoreByAfter = function (str) {
    if (str === undefined) return false;

var fullStr = _this3.input.value;
    var index = fullStr.lastIndexOf(str);

if (index === -1) return false;

if (index + str.length === fullStr.length) {
      _this3.fixCaret(index, index);

return true;
    }
    return false;
  };

this.partRestoreByAfter = function (str) {
    if (str === undefined) return false;

// For loop from full str to the str with last char to map. e.g. 123
    // -> 123
    // -> 23
    // -> 3
    return Array.prototype.some.call(str, function (_, start) {
      var partStr = str.substring(start);

return _this3.restoreByAfter(partStr);
    });
  };

this.stop = function () {
    if (_this3.autoStepTimer) {
      clearTimeout(_this3.autoStepTimer);
    }
  };

this.down = function (e, ratio, recursive) {
    _this3.pressingUpOrDown = true;
    _this3.step('down', e, ratio, recursive);
  };

this.up = function (e, ratio, recursive) {
    _this3.pressingUpOrDown = true;
    _this3.step('up', e, ratio, recursive);
  };

this.saveUp = function (node) {
    _this3.upHandler = node;
  };

this.saveDown = function (node) {
    _this3.downHandler = node;
  };

this.saveInput = function (node) {
    _this3.input = node;
  };
};

/* harmony default export */ __webpack_exports__["a"] = (InputNumber);

/***/ }),
/* 1141 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_resize_observer_polyfill__ = __webpack_require__(341);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__SubMenu__ = __webpack_require__(469);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__util__ = __webpack_require__(111);
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

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

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
var MENUITEM_OVERFLOWED_CLASSNAME = 'menuitem-overflowed';
var FLOAT_PRECISION_ADJUST = 0.5; // Fix ssr

if (canUseDOM) {
  // eslint-disable-next-line global-require
  __webpack_require__(1105);
}

var DOMWrap =
/*#__PURE__*/
function (_React$Component) {
  _inherits(DOMWrap, _React$Component);

function DOMWrap() {
    var _this;

_classCallCheck(this, DOMWrap);

_this = _possibleConstructorReturn(this, _getPrototypeOf(DOMWrap).apply(this, arguments));
    _this.resizeObserver = null;
    _this.mutationObserver = null; // original scroll size of the list

_this.originalTotalWidth = 0; // copy of overflowed items

_this.overflowedItems = []; // cache item of the original items (so we can track the size and order)

_this.menuItemSizes = [];
    _this.state = {
      lastVisibleIndex: undefined
    }; // get all valid menuItem nodes

_this.getMenuItemNodes = function () {
      var prefixCls = _this.props.prefixCls;
      var ul = __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.findDOMNode(_assertThisInitialized(_this));

if (!ul) {
        return [];
      } // filter out all overflowed indicator placeholder

return [].slice.call(ul.children).filter(function (node) {
        return node.className.split(' ').indexOf("".concat(prefixCls, "-overflowed-submenu")) < 0;
      });
    };

_this.getOverflowedSubMenuItem = function (keyPrefix, overflowedItems, renderPlaceholder) {
      var _this$props = _this.props,
          overflowedIndicator = _this$props.overflowedIndicator,
          level = _this$props.level,
          mode = _this$props.mode,
          prefixCls = _this$props.prefixCls,
          theme = _this$props.theme;

if (level !== 1 || mode !== 'horizontal') {
        return null;
      } // put all the overflowed item inside a submenu
      // with a title of overflow indicator ('...')

var copy = _this.props.children[0];

var _copy$props = copy.props,
          throwAway = _copy$props.children,
          title = _copy$props.title,
          propStyle = _copy$props.style,
          rest = _objectWithoutProperties(_copy$props, ["children", "title", "style"]);

var style = _objectSpread({}, propStyle);

var key = "".concat(keyPrefix, "-overflowed-indicator");
      var eventKey = "".concat(keyPrefix, "-overflowed-indicator");

if (overflowedItems.length === 0 && renderPlaceholder !== true) {
        style = _objectSpread({}, style, {
          display: 'none'
        });
      } else if (renderPlaceholder) {
        style = _objectSpread({}, style, {
          visibility: 'hidden',
          // prevent from taking normal dom space
          position: 'absolute'
        });
        key = "".concat(key, "-placeholder");
        eventKey = "".concat(eventKey, "-placeholder");
      }

_this.setChildrenWidthAndResize = function () {
      if (_this.props.mode !== 'horizontal') {
        return;
      }

var ul = __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.findDOMNode(_assertThisInitialized(_this));

if (!ul) {
        return;
      }

var ulChildrenNodes = ul.children;

if (!ulChildrenNodes || ulChildrenNodes.length === 0) {
        return;
      }

var lastOverflowedIndicatorPlaceholder = ul.children[ulChildrenNodes.length - 1]; // need last overflowed indicator for calculating length;

__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_4__util__["f" /* setStyle */])(lastOverflowedIndicatorPlaceholder, 'display', 'inline-block');

var menuItemNodes = _this.getMenuItemNodes(); // reset display attribute for all hidden elements caused by overflow to calculate updated width
      // and then reset to original state after width calculation

_this.handleResize(); // prevent the overflowed indicator from taking space;

__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_4__util__["f" /* setStyle */])(lastOverflowedIndicatorPlaceholder, 'display', 'none');
    };

_this.handleResize = function () {
      if (_this.props.mode !== 'horizontal') {
        return;
      }

var ul = __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.findDOMNode(_assertThisInitialized(_this));

if (!ul) {
        return;
      }

var width = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_4__util__["g" /* getWidth */])(ul);
      _this.overflowedItems = [];
      var currentSumWidth = 0; // index for last visible child in horizontal mode

var lastVisibleIndex; // float number comparison could be problematic
      // e.g. 0.1 + 0.2 > 0.3 =====> true
      // thus using FLOAT_PRECISION_ADJUST as buffer to help the situation

if (_this.originalTotalWidth > width + FLOAT_PRECISION_ADJUST) {
        lastVisibleIndex = -1;

_this.menuItemSizes.forEach(function (liWidth) {
          currentSumWidth += liWidth;

if (currentSumWidth + _this.overflowedIndicatorWidth <= width) {
            lastVisibleIndex += 1;
          }
        });
      }

_this.setState({
        lastVisibleIndex: lastVisibleIndex
      });
    };

return _this;
  }

_createClass(DOMWrap, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      var _this2 = this;

this.setChildrenWidthAndResize();

if (this.props.level === 1 && this.props.mode === 'horizontal') {
        var menuUl = __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.findDOMNode(this);

if (!menuUl) {
          return;
        }

this.resizeObserver = new __WEBPACK_IMPORTED_MODULE_2_resize_observer_polyfill__["default"](function (entries) {
          entries.forEach(_this2.setChildrenWidthAndResize);
        });
        [].slice.call(menuUl.children).concat(menuUl).forEach(function (el) {
          _this2.resizeObserver.observe(el);
        });

if (typeof MutationObserver !== 'undefined') {
          this.mutationObserver = new MutationObserver(function () {
            _this2.resizeObserver.disconnect();

[].slice.call(menuUl.children).concat(menuUl).forEach(function (el) {
              _this2.resizeObserver.observe(el);
            });

_this2.setChildrenWidthAndResize();
          });
          this.mutationObserver.observe(menuUl, {
            attributes: false,
            childList: true,
            subTree: false
          });
        }
      }
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      if (this.resizeObserver) {
        this.resizeObserver.disconnect();
      }

if (this.mutationObserver) {
        this.resizeObserver.disconnect();
      }
    }
  }, {
    key: "renderChildren",
    value: function renderChildren(children) {
      var _this3 = this;

// need to take care of overflowed items in horizontal mode
      var lastVisibleIndex = this.state.lastVisibleIndex;
      return (children || []).reduce(function (acc, childNode, index) {
        var item = childNode;

if (_this3.props.mode === 'horizontal') {
          var overflowed = _this3.getOverflowedSubMenuItem(childNode.props.eventKey, []);

if (lastVisibleIndex !== undefined && _this3.props.className.indexOf("".concat(_this3.props.prefixCls, "-root")) !== -1) {
            if (index > lastVisibleIndex) {
              item = __WEBPACK_IMPORTED_MODULE_0_react___default.a.cloneElement(childNode, // 这里修改 eventKey 是为了防止隐藏状态下还会触发 openkeys 事件
              {
                style: {
                  display: 'none'
                },
                eventKey: "".concat(childNode.props.eventKey, "-hidden"),

/**
                 * Legacy code. Here `className` never used:
                 * https://github.com/react-component/menu/commit/4cd6b49fce9d116726f4ea00dda85325d6f26500#diff-e2fa48f75c2dd2318295cde428556a76R240
                 */
                className: "".concat(MENUITEM_OVERFLOWED_CLASSNAME)
              });
            }

if (index === lastVisibleIndex + 1) {
              _this3.overflowedItems = children.slice(lastVisibleIndex + 1).map(function (c) {
                return __WEBPACK_IMPORTED_MODULE_0_react___default.a.cloneElement(c, // children[index].key will become '.$key' in clone by default,
                // we have to overwrite with the correct key explicitly
                {
                  key: c.props.eventKey,
                  mode: 'vertical-left'
                });
              });
              overflowed = _this3.getOverflowedSubMenuItem(childNode.props.eventKey, _this3.overflowedItems);
            }
          }

var ret = [].concat(_toConsumableArray(acc), [overflowed, item]);

if (index === children.length - 1) {
            // need a placeholder for calculating overflowed indicator width
            ret.push(_this3.getOverflowedSubMenuItem(childNode.props.eventKey, [], true));
          }

return ret;
        }

return [].concat(_toConsumableArray(acc), [item]);
      }, []);
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props2 = this.props,
          hiddenClassName = _this$props2.hiddenClassName,
          visible = _this$props2.visible,
          prefixCls = _this$props2.prefixCls,
          overflowedIndicator = _this$props2.overflowedIndicator,
          mode = _this$props2.mode,
          level = _this$props2.level,
          tag = _this$props2.tag,
          children = _this$props2.children,
          theme = _this$props2.theme,
          rest = _objectWithoutProperties(_this$props2, ["hiddenClassName", "visible", "prefixCls", "overflowedIndicator", "mode", "level", "tag", "children", "theme"]);

if (!visible) {
        rest.className += " ".concat(hiddenClassName);
      }

var Tag = tag;
      return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(Tag, Object.assign({}, rest), this.renderChildren(children));
    }
  }]);

return DOMWrap;
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);

DOMWrap.defaultProps = {
  tag: 'div',
  className: ''
};
/* harmony default export */ __webpack_exports__["a"] = (DOMWrap);

/***/ }),
/* 1142 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var Divider = function Divider(_ref) {
  var className = _ref.className,
      rootPrefixCls = _ref.rootPrefixCls,
      style = _ref.style;
  return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("li", {
    className: "".concat(className, " ").concat(rootPrefixCls, "-item-divider"),
    style: style
  });
};

Divider.defaultProps = {
  // To fix keyboard UX.
  disabled: true,
  className: '',
  style: {}
};
/* harmony default export */ __webpack_exports__["a"] = (Divider);

/***/ }),
/* 1143 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var Menu =
/*#__PURE__*/
function (_React$Component) {
  _inherits(Menu, _React$Component);

function Menu(props) {
    var _this;

_classCallCheck(this, Menu);

_this = _possibleConstructorReturn(this, _getPrototypeOf(Menu).call(this, props));

_this.onSelect = function (selectInfo) {
      var _assertThisInitialize = _assertThisInitialized(_this),
          props = _assertThisInitialize.props;

if (props.selectable) {
        // root menu
        var _this$store$getState = _this.store.getState(),
            _selectedKeys = _this$store$getState.selectedKeys;

var selectedKey = selectInfo.key;

if (props.multiple) {
          _selectedKeys = _selectedKeys.concat([selectedKey]);
        } else {
          _selectedKeys = [selectedKey];
        }

if (!('selectedKeys' in props)) {
          _this.store.setState({
            selectedKeys: _selectedKeys
          });
        }

props.onSelect(_objectSpread({}, selectInfo, {
          selectedKeys: _selectedKeys
        }));
      }
    };

_this.onClick = function (e) {
      _this.props.onClick(e);
    }; // onKeyDown needs to be exposed as a instance method
    // e.g., in rc-select, we need to navigate menu item while
    // current active item is rc-select input box rather than the menu itself

_this.onKeyDown = function (e, callback) {
      _this.innerMenu.getWrappedInstance().onKeyDown(e, callback);
    };

_this.onOpenChange = function (event) {
      var _assertThisInitialize2 = _assertThisInitialized(_this),
          props = _assertThisInitialize2.props;

var openKeys = _this.store.getState().openKeys.concat();

var changed = false;

var processSingle = function processSingle(e) {
        var oneChanged = false;

if (e.open) {
          oneChanged = openKeys.indexOf(e.key) === -1;

if (oneChanged) {
            openKeys.push(e.key);
          }
        } else {
          var index = openKeys.indexOf(e.key);
          oneChanged = index !== -1;

if (oneChanged) {
            openKeys.splice(index, 1);
          }
        }

changed = changed || oneChanged;
      };

if (Array.isArray(event)) {
        // batch change call
        event.forEach(processSingle);
      } else {
        processSingle(event);
      }

if (changed) {
        if (!('openKeys' in _this.props)) {
          _this.store.setState({
            openKeys: openKeys
          });
        }

props.onOpenChange(openKeys);
      }
    };

_this.onDeselect = function (selectInfo) {
      var _assertThisInitialize3 = _assertThisInitialized(_this),
          props = _assertThisInitialize3.props;

if (props.selectable) {
        var _selectedKeys2 = _this.store.getState().selectedKeys.concat();

var selectedKey = selectInfo.key;

var index = _selectedKeys2.indexOf(selectedKey);

if (index !== -1) {
          _selectedKeys2.splice(index, 1);
        }

if (!('selectedKeys' in props)) {
          _this.store.setState({
            selectedKeys: _selectedKeys2
          });
        }

props.onDeselect(_objectSpread({}, selectInfo, {
          selectedKeys: _selectedKeys2
        }));
      }
    };

_this.getOpenTransitionName = function () {
      var _assertThisInitialize4 = _assertThisInitialized(_this),
          props = _assertThisInitialize4.props;

var transitionName = props.openTransitionName;
      var animationName = props.openAnimation;

if (!transitionName && typeof animationName === 'string') {
        transitionName = "".concat(props.prefixCls, "-open-").concat(animationName);
      }

return transitionName;
    };

_this.setInnerMenu = function (node) {
      _this.innerMenu = node;
    };

_this.isRootMenu = true;
    var selectedKeys = props.defaultSelectedKeys;
    var openKeys = props.defaultOpenKeys;

if ('selectedKeys' in props) {
      selectedKeys = props.selectedKeys || [];
    }

if ('openKeys' in props) {
      openKeys = props.openKeys || [];
    }

_this.store = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_1_mini_store__["create"])({
      selectedKeys: selectedKeys,
      openKeys: openKeys,
      activeKey: {
        '0-menu-': __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__SubPopupMenu__["a" /* getActiveKey */])(props, props.activeKey)
      }
    });
    return _this;
  }

_createClass(Menu, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.updateMiniStore();
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate() {
      this.updateMiniStore();
    }
  }, {
    key: "updateMiniStore",
    value: function updateMiniStore() {
      if ('selectedKeys' in this.props) {
        this.store.setState({
          selectedKeys: this.props.selectedKeys || []
        });
      }

if ('openKeys' in this.props) {
        this.store.setState({
          openKeys: this.props.openKeys || []
        });
      }
    }
  }, {
    key: "render",
    value: function render() {
      var props = _objectSpread({}, this.props);

props.className += " ".concat(props.prefixCls, "-root");
      props = _objectSpread({}, props, {
        onClick: this.onClick,
        onOpenChange: this.onOpenChange,
        onDeselect: this.onDeselect,
        onSelect: this.onSelect,
        openTransitionName: this.getOpenTransitionName(),
        parentMenu: this
      });
      return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_1_mini_store__["Provider"], {
        store: this.store
      }, __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2__SubPopupMenu__["b" /* default */], Object.assign({}, props, {
        ref: this.setInnerMenu
      }), this.props.children));
    }
  }]);

return Menu;
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);

Menu.defaultProps = {
  selectable: true,
  onClick: __WEBPACK_IMPORTED_MODULE_3__util__["a" /* noop */],
  onSelect: __WEBPACK_IMPORTED_MODULE_3__util__["a" /* noop */],
  onOpenChange: __WEBPACK_IMPORTED_MODULE_3__util__["a" /* noop */],
  onDeselect: __WEBPACK_IMPORTED_MODULE_3__util__["a" /* noop */],
  defaultSelectedKeys: [],
  defaultOpenKeys: [],
  subMenuOpenDelay: 0.1,
  subMenuCloseDelay: 0.1,
  triggerSubMenuAction: 'hover',
  prefixCls: 'rc-menu',
  className: '',
  mode: 'vertical',
  style: {},
  builtinPlacements: {},
  overflowedIndicator: __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("span", null, "\xB7\xB7\xB7")
};
/* harmony default export */ __webpack_exports__["a"] = (Menu);

/***/ }),
/* 1144 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export MenuItem */
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__ = __webpack_require__(87);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_dom_scroll_into_view__ = __webpack_require__(402);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_dom_scroll_into_view___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_dom_scroll_into_view__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_mini_store__ = __webpack_require__(185);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_mini_store___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_mini_store__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__util__ = __webpack_require__(111);
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var MenuItem =
/*#__PURE__*/
function (_React$Component) {
  _inherits(MenuItem, _React$Component);

function MenuItem() {
    var _this;

_classCallCheck(this, MenuItem);

_this = _possibleConstructorReturn(this, _getPrototypeOf(MenuItem).apply(this, arguments));

_this.onKeyDown = function (e) {
      var keyCode = e.keyCode;

if (keyCode === __WEBPACK_IMPORTED_MODULE_2_rc_util_es_KeyCode__["a" /* default */].ENTER) {
        _this.onClick(e);

return true;
      }

return undefined;
    };

_this.onMouseLeave = function (e) {
      var _this$props = _this.props,
          eventKey = _this$props.eventKey,
          onItemHover = _this$props.onItemHover,
          onMouseLeave = _this$props.onMouseLeave;
      onItemHover({
        key: eventKey,
        hover: false
      });
      onMouseLeave({
        key: eventKey,
        domEvent: e
      });
    };

_this.onMouseEnter = function (e) {
      var _this$props2 = _this.props,
          eventKey = _this$props2.eventKey,
          onItemHover = _this$props2.onItemHover,
          onMouseEnter = _this$props2.onMouseEnter;
      onItemHover({
        key: eventKey,
        hover: true
      });
      onMouseEnter({
        key: eventKey,
        domEvent: e
      });
    };

_this.onClick = function (e) {
      var _this$props3 = _this.props,
          eventKey = _this$props3.eventKey,
          multiple = _this$props3.multiple,
          onClick = _this$props3.onClick,
          onSelect = _this$props3.onSelect,
          onDeselect = _this$props3.onDeselect,
          isSelected = _this$props3.isSelected;
      var info = {
        key: eventKey,
        keyPath: [eventKey],
        item: _assertThisInitialized(_this),
        domEvent: e
      };
      onClick(info);

if (multiple) {
        if (isSelected) {
          onDeselect(info);
        } else {
          onSelect(info);
        }
      } else if (!isSelected) {
        onSelect(info);
      }
    };

_this.saveNode = function (node) {
      _this.node = node;
    };

return _this;
  }

_createClass(MenuItem, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      // invoke customized ref to expose component to mixin
      this.callRef();
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate(prevProps) {
      var _this$props4 = this.props,
          active = _this$props4.active,
          parentMenu = _this$props4.parentMenu,
          eventKey = _this$props4.eventKey; // 在 parentMenu 上层保存滚动状态，避免重复的 MenuItem key 导致滚动跳动
      // https://github.com/ant-design/ant-design/issues/16181

if (!prevProps.active && active && (!parentMenu || !parentMenu["scrolled-".concat(eventKey)])) {
        if (this.node) {
          __WEBPACK_IMPORTED_MODULE_4_dom_scroll_into_view___default()(this.node, __WEBPACK_IMPORTED_MODULE_1_react_dom___default.a.findDOMNode(parentMenu), {
            onlyScrollIfNeeded: true
          });
          parentMenu["scrolled-".concat(eventKey)] = true;
        }
      } else if (parentMenu && parentMenu["scrolled-".concat(eventKey)]) {
        delete parentMenu["scrolled-".concat(eventKey)];
      }

this.callRef();
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      var props = this.props;

if (props.onDestroy) {
        props.onDestroy(props.eventKey);
      }
    }
  }, {
    key: "getPrefixCls",
    value: function getPrefixCls() {
      return "".concat(this.props.rootPrefixCls, "-item");
    }
  }, {
    key: "getActiveClassName",
    value: function getActiveClassName() {
      return "".concat(this.getPrefixCls(), "-active");
    }
  }, {
    key: "getSelectedClassName",
    value: function getSelectedClassName() {
      return "".concat(this.getPrefixCls(), "-selected");
    }
  }, {
    key: "getDisabledClassName",
    value: function getDisabledClassName() {
      return "".concat(this.getPrefixCls(), "-disabled");
    }
  }, {
    key: "callRef",
    value: function callRef() {
      if (this.props.manualRef) {
        this.props.manualRef(this);
      }
    }
  }, {
    key: "render",
    value: function render() {
      var _classNames;

var props = _objectSpread({}, this.props);

var className = __WEBPACK_IMPORTED_MODULE_3_classnames___default()(this.getPrefixCls(), props.className, (_classNames = {}, _defineProperty(_classNames, this.getActiveClassName(), !props.disabled && props.active), _defineProperty(_classNames, this.getSelectedClassName(), props.isSelected), _defineProperty(_classNames, this.getDisabledClassName(), props.disabled), _classNames));

var attrs = _objectSpread({}, props.attribute, {
        title: props.title,
        className: className,
        // set to menuitem by default
        role: props.role || 'menuitem',
        'aria-disabled': props.disabled
      });

if (props.role === 'option') {
        // overwrite to option
        attrs = _objectSpread({}, attrs, {
          role: 'option',
          'aria-selected': props.isSelected
        });
      } else if (props.role === null || props.role === 'none') {
        // sometimes we want to specify role inside <li/> element
        // <li><a role='menuitem'>Link</a></li> would be a good example
        // in this case the role on <li/> should be "none" to
        // remove the implied listitem role.
        // https://www.w3.org/TR/wai-aria-practices-1.1/examples/menubar/menubar-1/menubar-1.html
        attrs.role = 'none';
      } // In case that onClick/onMouseLeave/onMouseEnter is passed down from owner

var mouseEvent = {
        onClick: props.disabled ? null : this.onClick,
        onMouseLeave: props.disabled ? null : this.onMouseLeave,
        onMouseEnter: props.disabled ? null : this.onMouseEnter
      };

var style = _objectSpread({}, props.style);

if (props.mode === 'inline') {
        style.paddingLeft = props.inlineIndent * props.level;
      }

__WEBPACK_IMPORTED_MODULE_6__util__["e" /* menuAllProps */].forEach(function (key) {
        return delete props[key];
      });
      var icon = this.props.itemIcon;

if (typeof this.props.itemIcon === 'function') {
        // TODO: This is a bug which should fixed after TS refactor
        icon = __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(this.props.itemIcon, this.props);
      }

return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("li", Object.assign({}, props, attrs, mouseEvent, {
        style: style,
        ref: this.saveNode
      }), props.children, icon);
    }
  }]);

return MenuItem;
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);
MenuItem.isMenuItem = true;
MenuItem.defaultProps = {
  onSelect: __WEBPACK_IMPORTED_MODULE_6__util__["a" /* noop */],
  onMouseEnter: __WEBPACK_IMPORTED_MODULE_6__util__["a" /* noop */],
  onMouseLeave: __WEBPACK_IMPORTED_MODULE_6__util__["a" /* noop */],
  manualRef: __WEBPACK_IMPORTED_MODULE_6__util__["a" /* noop */]
};
var connected = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_5_mini_store__["connect"])(function (_ref, _ref2) {
  var activeKey = _ref.activeKey,
      selectedKeys = _ref.selectedKeys;
  var eventKey = _ref2.eventKey,
      subMenuKey = _ref2.subMenuKey;
  return {
    active: activeKey[subMenuKey] === eventKey,
    isSelected: selectedKeys.indexOf(eventKey) !== -1
  };
})(MenuItem);
/* harmony default export */ __webpack_exports__["a"] = (connected);

/***/ }),
/* 1145 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var MenuItemGroup =
/*#__PURE__*/
function (_React$Component) {
  _inherits(MenuItemGroup, _React$Component);

function MenuItemGroup() {
    var _this;

_classCallCheck(this, MenuItemGroup);

_this = _possibleConstructorReturn(this, _getPrototypeOf(MenuItemGroup).apply(this, arguments));

_this.renderInnerMenuItem = function (item) {
      var _this$props = _this.props,
          renderMenuItem = _this$props.renderMenuItem,
          index = _this$props.index;
      return renderMenuItem(item, index, _this.props.subMenuKey);
    };

return _this;
  }

_createClass(MenuItemGroup, [{
    key: "render",
    value: function render() {
      var props = _extends({}, this.props);

var _props$className = props.className,
          className = _props$className === void 0 ? '' : _props$className,
          rootPrefixCls = props.rootPrefixCls;
      var titleClassName = "".concat(rootPrefixCls, "-item-group-title");
      var listClassName = "".concat(rootPrefixCls, "-item-group-list");
      var title = props.title,
          children = props.children;
      __WEBPACK_IMPORTED_MODULE_1__util__["e" /* menuAllProps */].forEach(function (key) {
        return delete props[key];
      }); // Set onClick to null, to ignore propagated onClick event

delete props.onClick;
      return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("li", Object.assign({}, props, {
        className: "".concat(className, " ").concat(rootPrefixCls, "-item-group")
      }), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("div", {
        className: titleClassName,
        title: typeof title === 'string' ? title : undefined
      }, title), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("ul", {
        className: listClassName
      }, __WEBPACK_IMPORTED_MODULE_0_react___default.a.Children.map(children, this.renderInnerMenuItem)));
    }
  }]);

return MenuItemGroup;
}(__WEBPACK_IMPORTED_MODULE_0_react___default.a.Component);

MenuItemGroup.isMenuItemGroup = true;
MenuItemGroup.defaultProps = {
  disabled: true
};
/* harmony default export */ __webpack_exports__["a"] = (MenuItemGroup);

/***/ }),
/* 1146 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export placements */
var autoAdjustOverflow = {
  adjustX: 1,
  adjustY: 1
};
var placements = {
  topLeft: {
    points: ['bl', 'tl'],
    overflow: autoAdjustOverflow,
    offset: [0, -7]
  },
  bottomLeft: {
    points: ['tl', 'bl'],
    overflow: autoAdjustOverflow,
    offset: [0, 7]
  },
  leftTop: {
    points: ['tr', 'tl'],
    overflow: autoAdjustOverflow,
    offset: [-4, 0]
  },
  rightTop: {
    points: ['tl', 'tr'],
    overflow: autoAdjustOverflow,
    offset: [4, 0]
  }
};
/* harmony default export */ __webpack_exports__["a"] = (placements);

/***/ }),
/* 1147 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

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

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

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

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

// MIT License from https://github.com/kaimallea/isMobile
var applePhone = /iPhone/i;
var appleIpod = /iPod/i;
var appleTablet = /iPad/i;
var androidPhone = /\bAndroid(?:.+)Mobile\b/i; // Match 'Android' AND 'Mobile'

var androidTablet = /Android/i;
var amazonPhone = /\bAndroid(?:.+)SD4930UR\b/i;
var amazonTablet = /\bAndroid(?:.+)(?:KF[A-Z]{2,4})\b/i;
var windowsPhone = /Windows Phone/i;
var windowsTablet = /\bWindows(?:.+)ARM\b/i; // Match 'Windows' AND 'ARM'

var otherBlackberry = /BlackBerry/i;
var otherBlackberry10 = /BB10/i;
var otherOpera = /Opera Mini/i;
var otherChrome = /\b(CriOS|Chrome)(?:.+)Mobile/i;
var otherFirefox = /Mobile(?:.+)Firefox\b/i; // Match 'Mobile' AND 'Firefox'

function match(regex, userAgent) {
  return regex.test(userAgent);
}

function isMobile(userAgent) {
  var ua = userAgent || (typeof navigator !== 'undefined' ? navigator.userAgent : ''); // Facebook mobile app's integrated browser adds a bunch of strings that
  // match everything. Strip it out if it exists.

var tmp = ua.split('[FBAN');

if (typeof tmp[1] !== 'undefined') {
    var _tmp = tmp;

var _tmp2 = _slicedToArray(_tmp, 1);

ua = _tmp2[0];
  } // Twitter mobile app's integrated browser on iPad adds a "Twitter for
  // iPhone" string. Same probably happens on other tablet platforms.
  // This will confuse detection so strip it out if it exists.

tmp = ua.split('Twitter');

if (typeof tmp[1] !== 'undefined') {
    var _tmp3 = tmp;

var _tmp4 = _slicedToArray(_tmp3, 1);

ua = _tmp4[0];
  }

var result = {
    apple: {
      phone: match(applePhone, ua) && !match(windowsPhone, ua),
      ipod: match(appleIpod, ua),
      tablet: !match(applePhone, ua) && match(appleTablet, ua) && !match(windowsPhone, ua),
      device: (match(applePhone, ua) || match(appleIpod, ua) || match(appleTablet, ua)) && !match(windowsPhone, ua)
    },
    amazon: {
      phone: match(amazonPhone, ua),
      tablet: !match(amazonPhone, ua) && match(amazonTablet, ua),
      device: match(amazonPhone, ua) || match(amazonTablet, ua)
    },
    android: {
      phone: !match(windowsPhone, ua) && match(amazonPhone, ua) || !match(windowsPhone, ua) && match(androidPhone, ua),
      tablet: !match(windowsPhone, ua) && !match(amazonPhone, ua) && !match(androidPhone, ua) && (match(amazonTablet, ua) || match(androidTablet, ua)),
      device: !match(windowsPhone, ua) && (match(amazonPhone, ua) || match(amazonTablet, ua) || match(androidPhone, ua) || match(androidTablet, ua)) || match(/\bokhttp\b/i, ua)
    },
    windows: {
      phone: match(windowsPhone, ua),
      tablet: match(windowsTablet, ua),
      device: match(windowsPhone, ua) || match(windowsTablet, ua)
    },
    other: {
      blackberry: match(otherBlackberry, ua),
      blackberry10: match(otherBlackberry10, ua),
      opera: match(otherOpera, ua),
      firefox: match(otherFirefox, ua),
      chrome: match(otherChrome, ua),
      device: match(otherBlackberry, ua) || match(otherBlackberry10, ua) || match(otherOpera, ua) || match(otherFirefox, ua) || match(otherChrome, ua)
    },
    // Additional
    any: null,
    phone: null,
    tablet: null
  };
  result.any = result.apple.device || result.android.device || result.windows.device || result.other.device; // excludes 'other' devices and ipods, targeting touchscreen phones

result.phone = result.apple.phone || result.android.phone || result.windows.phone;
  result.tablet = result.apple.tablet || result.android.tablet || result.windows.tablet;
  return result;
}

var defaultResult = _objectSpread({}, isMobile(), {
  isMobile: isMobile
});

/* harmony default export */ __webpack_exports__["a"] = (defaultResult);

/***/ }),
/* 1148 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony default export */ __webpack_exports__["a"] = ({
  // Options.jsx
  items_per_page: '/ page',
  jump_to: 'Goto',
  jump_to_confirm: 'confirm',
  page: '',

// Pagination.jsx
  prev_page: 'Previous Page',
  next_page: 'Next Page',
  prev_5: 'Previous 5 Pages',
  next_5: 'Next 5 Pages',
  prev_3: 'Previous 3 Pages',
  next_3: 'Next 3 Pages'
});

/***/ }),
/* 1149 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DropdownMenu; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_dom_scroll_into_view__ = __webpack_require__(402);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_dom_scroll_into_view___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_dom_scroll_into_view__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_raf__ = __webpack_require__(298);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_raf___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_raf__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rc_menu__ = __webpack_require__(140);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rc_util_es_Children_toArray__ = __webpack_require__(480);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__util__ = __webpack_require__(299);
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

var DropdownMenu =
/*#__PURE__*/
function (_React$Component) {
  _inherits(DropdownMenu, _React$Component);

function DropdownMenu(props) {
    var _this;

_classCallCheck(this, DropdownMenu);

_this = _possibleConstructorReturn(this, _getPrototypeOf(DropdownMenu).call(this, props));
    _this.rafInstance = {
      cancel: function cancel() {
        return null;
      }
    };
    _this.lastVisible = false;

_this.scrollActiveItemToView = function () {
      // scroll into view
      var itemComponent = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6_react_dom__["findDOMNode"])(_this.firstActiveItem);
      var _this$props = _this.props,
          visible = _this$props.visible,
          firstActiveValue = _this$props.firstActiveValue;
      var value = _this.props.value;

if (!itemComponent || !visible) {
        return;
      }

var scrollIntoViewOpts = {
        onlyScrollIfNeeded: true
      };

if ((!value || value.length === 0) && firstActiveValue) {
        scrollIntoViewOpts.alignWithTop = true;
      } // Delay to scroll since current frame item position is not ready when pre view is by filter
      // https://github.com/ant-design/ant-design/issues/11268#issuecomment-406634462

_this.rafInstance = __WEBPACK_IMPORTED_MODULE_2_raf___default()(function () {
        __WEBPACK_IMPORTED_MODULE_0_dom_scroll_into_view___default()(itemComponent, __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6_react_dom__["findDOMNode"])(_this.menuRef), scrollIntoViewOpts);
      });
    };

_this.renderMenu = function () {
      var _this$props2 = _this.props,
          menuItems = _this$props2.menuItems,
          menuItemSelectedIcon = _this$props2.menuItemSelectedIcon,
          defaultActiveFirstOption = _this$props2.defaultActiveFirstOption,
          prefixCls = _this$props2.prefixCls,
          multiple = _this$props2.multiple,
          onMenuSelect = _this$props2.onMenuSelect,
          inputValue = _this$props2.inputValue,
          backfillValue = _this$props2.backfillValue,
          onMenuDeselect = _this$props2.onMenuDeselect,
          visible = _this$props2.visible;
      var firstActiveValue = _this.props.firstActiveValue;

if (menuItems && menuItems.length) {
        var menuProps = {};

if (multiple) {
          menuProps.onDeselect = onMenuDeselect;
          menuProps.onSelect = onMenuSelect;
        } else {
          menuProps.onClick = onMenuSelect;
        }

var value = _this.props.value;
        var selectedKeys = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7__util__["v" /* getSelectKeys */])(menuItems, value);
        var activeKeyProps = {};
        var clonedMenuItems = menuItems;

if (selectedKeys.length || firstActiveValue) {
          if (visible && !_this.lastVisible) {
            activeKeyProps.activeKey = selectedKeys[0] || firstActiveValue;
          } else if (!visible) {
            activeKeyProps.activeKey = undefined;
          }

var foundFirst = false; // set firstActiveItem via cloning menus
          // for scroll into view

var clone = function clone(item) {
            var key = item.key;

if (!foundFirst && selectedKeys.indexOf(key) !== -1 || !foundFirst && !selectedKeys.length && firstActiveValue.indexOf(item.key) !== -1) {
              foundFirst = true;
              return __WEBPACK_IMPORTED_MODULE_5_react__["cloneElement"](item, {
                ref: function ref(_ref) {
                  _this.firstActiveItem = _ref;
                }
              });
            }

return item;
          };

clonedMenuItems = menuItems.map(function (item) {
            if (item.type.isMenuItemGroup) {
              var children = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_4_rc_util_es_Children_toArray__["a" /* default */])(item.props.children).map(clone);
              return __WEBPACK_IMPORTED_MODULE_5_react__["cloneElement"](item, {}, children);
            }

return clone(item);
          });
        } else {
          // Clear firstActiveItem when dropdown menu items was empty
          // Avoid `Unable to find node on an unmounted component`
          // https://github.com/ant-design/ant-design/issues/10774
          _this.firstActiveItem = null;
        } // clear activeKey when inputValue change

var lastValue = value && value[value.length - 1];

if (inputValue !== _this.lastInputValue && (!lastValue || lastValue !== backfillValue)) {
          activeKeyProps.activeKey = '';
        }

return __WEBPACK_IMPORTED_MODULE_5_react__["createElement"](__WEBPACK_IMPORTED_MODULE_3_rc_menu__["c" /* default */], _extends({
          ref: _this.saveMenuRef,
          style: _this.props.dropdownMenuStyle,
          defaultActiveFirst: defaultActiveFirstOption,
          role: "listbox",
          itemIcon: multiple ? menuItemSelectedIcon : null
        }, activeKeyProps, {
          multiple: multiple
        }, menuProps, {
          selectedKeys: selectedKeys,
          prefixCls: "".concat(prefixCls, "-menu")
        }), clonedMenuItems);
      }

return null;
    };

_this.lastInputValue = props.inputValue;
    _this.saveMenuRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_7__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'menuRef');
    return _this;
  }

_createClass(DropdownMenu, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.scrollActiveItemToView();
      this.lastVisible = this.props.visible;
    }
  }, {
    key: "shouldComponentUpdate",
    value: function shouldComponentUpdate(nextProps) {
      if (!nextProps.visible) {
        this.lastVisible = false;
      } // freeze when hide

return this.props.visible && !nextProps.visible || nextProps.visible || nextProps.inputValue !== this.props.inputValue;
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate(prevProps) {
      var props = this.props;

if (!prevProps.visible && props.visible) {
        this.scrollActiveItemToView();
      }

this.lastVisible = props.visible;
      this.lastInputValue = props.inputValue;
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      if (this.rafInstance && this.rafInstance.cancel) {
        this.rafInstance.cancel();
      }
    }
  }, {
    key: "render",
    value: function render() {
      var renderMenu = this.renderMenu();
      return renderMenu ? __WEBPACK_IMPORTED_MODULE_5_react__["createElement"]("div", {
        style: {
          overflow: 'auto',
          transform: 'translateZ(0)'
        },
        id: this.props.ariaId,
        onFocus: this.props.onPopupFocus,
        onMouseDown: __WEBPACK_IMPORTED_MODULE_7__util__["m" /* preventDefaultEvent */],
        onScroll: this.props.onPopupScroll
      }, renderMenu) : null;
    }
  }]);

return DropdownMenu;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

DropdownMenu.displayName = 'DropdownMenu';
DropdownMenu.propTypes = {
  ariaId: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"],
  defaultActiveFirstOption: __WEBPACK_IMPORTED_MODULE_1_prop_types__["bool"],
  value: __WEBPACK_IMPORTED_MODULE_1_prop_types__["any"],
  dropdownMenuStyle: __WEBPACK_IMPORTED_MODULE_1_prop_types__["object"],
  multiple: __WEBPACK_IMPORTED_MODULE_1_prop_types__["bool"],
  onPopupFocus: __WEBPACK_IMPORTED_MODULE_1_prop_types__["func"],
  onPopupScroll: __WEBPACK_IMPORTED_MODULE_1_prop_types__["func"],
  onMenuDeSelect: __WEBPACK_IMPORTED_MODULE_1_prop_types__["func"],
  onMenuSelect: __WEBPACK_IMPORTED_MODULE_1_prop_types__["func"],
  prefixCls: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"],
  menuItems: __WEBPACK_IMPORTED_MODULE_1_prop_types__["any"],
  inputValue: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"],
  visible: __WEBPACK_IMPORTED_MODULE_1_prop_types__["bool"],
  firstActiveValue: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"],
  menuItemSelectedIcon: __WEBPACK_IMPORTED_MODULE_1_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_1_prop_types__["func"], __WEBPACK_IMPORTED_MODULE_1_prop_types__["node"]])
};

/***/ }),
/* 1150 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return OptGroup; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__);
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var OptGroup =
/*#__PURE__*/
function (_Component) {
  _inherits(OptGroup, _Component);

function OptGroup() {
    _classCallCheck(this, OptGroup);

return _possibleConstructorReturn(this, _getPrototypeOf(OptGroup).apply(this, arguments));
  }

return OptGroup;
}(__WEBPACK_IMPORTED_MODULE_0_react__["Component"]);

OptGroup.isSelectOptGroup = true;

/***/ }),
/* 1151 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_component_classes__ = __webpack_require__(386);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_component_classes___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_component_classes__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rc_animate__ = __webpack_require__(139);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_rc_menu__ = __webpack_require__(140);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_rc_util_es_Children_toArray__ = __webpack_require__(480);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__ = __webpack_require__(87);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_react_lifecycles_compat__ = __webpack_require__(61);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_warning__ = __webpack_require__(117);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_warning___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_warning__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__Option__ = __webpack_require__(471);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__PropTypes__ = __webpack_require__(472);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__SelectTrigger__ = __webpack_require__(1152);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__util__ = __webpack_require__(299);
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

var SELECT_EMPTY_VALUE_KEY = 'RC_SELECT_EMPTY_VALUE_KEY';

var noop = function noop() {
  return null;
};

function chaining() {
  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
    fns[_key] = arguments[_key];
  }

return function () {
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

// tslint:disable-next-line:prefer-for-of
    for (var i = 0; i < fns.length; i++) {
      if (fns[i] && typeof fns[i] === 'function') {
        fns[i].apply(chaining, args);
      }
    }
  };
}

var Select =
/*#__PURE__*/
function (_React$Component) {
  _inherits(Select, _React$Component);

function Select(props) {
    var _this;

_classCallCheck(this, Select);

_this = _possibleConstructorReturn(this, _getPrototypeOf(Select).call(this, props));
    _this.inputRef = null;
    _this.inputMirrorRef = null;
    _this.topCtrlRef = null;
    _this.selectTriggerRef = null;
    _this.rootRef = null;
    _this.selectionRef = null;
    _this.dropdownContainer = null;
    _this.blurTimer = null;
    _this.focusTimer = null; // tslint:disable-next-line:variable-name

_this._focused = false; // tslint:disable-next-line:variable-name

_this._mouseDown = false; // tslint:disable-next-line:variable-name

_this._options = [];

_this.onInputChange = function (event) {
      var tokenSeparators = _this.props.tokenSeparators;
      var val = event.target.value;

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(_this.props) && tokenSeparators.length && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["b" /* includesSeparators */])(val, tokenSeparators)) {
        var nextValue = _this.getValueByInput(val);

if (nextValue !== undefined) {
          _this.fireChange(nextValue);
        }

_this.setOpenState(false, true);

_this.setInputValue('', false);

return;
      }

_this.setInputValue(val);

_this.setState({
        open: true
      });

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["c" /* isCombobox */])(_this.props)) {
        _this.fireChange([val]);
      }
    };

_this.onDropdownVisibleChange = function (open) {
      if (open && !_this._focused) {
        _this.clearBlurTime();

_this.timeoutFocus();

_this._focused = true;

_this.updateFocusClassName();
      }

_this.setOpenState(open);
    }; // combobox ignore

_this.onKeyDown = function (event) {
      var open = _this.state.open;
      var disabled = _this.props.disabled;

if (disabled) {
        return;
      }

var keyCode = event.keyCode;

if (open && !_this.getInputDOMNode()) {
        _this.onInputKeyDown(event);
      } else if (keyCode === __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__["a" /* default */].ENTER || keyCode === __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__["a" /* default */].DOWN) {
        if (!open) {
          _this.setOpenState(true);
        }

event.preventDefault();
      } else if (keyCode === __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__["a" /* default */].SPACE) {
        // Not block space if popup is shown
        if (!open) {
          _this.setOpenState(true);

event.preventDefault();
        }
      }
    };

_this.onInputKeyDown = function (event) {
      var props = _this.props;

if (props.disabled) {
        return;
      }

var state = _this.state; // magic code

var keyCode = event.keyCode;

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(props) && !event.target.value && keyCode === __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__["a" /* default */].BACKSPACE) {
        event.preventDefault();
        var value = state.value;

if (value.length) {
          _this.removeSelected(value[value.length - 1]);
        }

return;
      }

if (keyCode === __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__["a" /* default */].DOWN) {
        if (!state.open) {
          _this.openIfHasChildren();

event.preventDefault();
          event.stopPropagation();
          return;
        }
      } else if (keyCode === __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__["a" /* default */].ENTER && state.open) {
        // Aviod trigger form submit when select item
        // https://github.com/ant-design/ant-design/issues/10861
        event.preventDefault();
      } else if (keyCode === __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__["a" /* default */].ESC) {
        if (state.open) {
          _this.setOpenState(false);

event.preventDefault();
          event.stopPropagation();
        }

return;
      }

if (_this.getRealOpenState(state) && _this.selectTriggerRef) {
        var menu = _this.selectTriggerRef.getInnerMenu();

if (menu && menu.onKeyDown(event, _this.handleBackfill)) {
          event.preventDefault();
          event.stopPropagation();
        }
      }
    };

_this.onMenuSelect = function (_ref) {
      var item = _ref.item;

if (!item) {
        return;
      }

var value = _this.state.value;
      var props = _this.props;
      var selectedValue = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(item);
      var lastValue = value[value.length - 1];

_this.fireSelect(selectedValue);

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(props)) {
        if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["e" /* findIndexInValueBySingleValue */])(value, selectedValue) !== -1) {
          return;
        }

value = value.concat([selectedValue]);
      } else {
        if (lastValue !== undefined && lastValue === selectedValue && selectedValue !== _this.state.backfillValue) {
          _this.setOpenState(false, true);

return;
        }

value = [selectedValue];

_this.setOpenState(false, true);
      }

_this.fireChange(value);

var inputValue = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["c" /* isCombobox */])(props) ? __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["f" /* getPropValue */])(item, props.optionLabelProp) : '';

if (props.autoClearSearchValue) {
        _this.setInputValue(inputValue, false);
      }
    };

_this.onMenuDeselect = function (_ref2) {
      var item = _ref2.item,
          domEvent = _ref2.domEvent;

if (domEvent.type === 'keydown' && domEvent.keyCode === __WEBPACK_IMPORTED_MODULE_5_rc_util_es_KeyCode__["a" /* default */].ENTER) {
        _this.removeSelected(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(item));

return;
      }

if (domEvent.type === 'click') {
        _this.removeSelected(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(item));
      }

var props = _this.props;

if (props.autoClearSearchValue) {
        _this.setInputValue('', false);
      }
    };

_this.onArrowClick = function (e) {
      e.stopPropagation();
      e.preventDefault();

if (!_this.props.disabled) {
        _this.setOpenState(!_this.state.open, !_this.state.open);
      }
    };

_this.onPlaceholderClick = function () {
      if (_this.getInputDOMNode && _this.getInputDOMNode()) {
        _this.getInputDOMNode().focus();
      }
    };

_this.onOuterFocus = function (e) {
      if (_this.props.disabled) {
        e.preventDefault();
        return;
      }

_this.clearBlurTime();

if (!__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["g" /* isMultipleOrTagsOrCombobox */])(_this.props) && e.target === _this.getInputDOMNode()) {
        return;
      }

if (_this._focused) {
        return;
      }

_this._focused = true;

_this.updateFocusClassName(); // only effect multiple or tag mode

if (!__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(_this.props) || !_this._mouseDown) {
        _this.timeoutFocus();
      }
    };

_this.onPopupFocus = function () {
      // fix ie scrollbar, focus element again
      _this.maybeFocus(true, true);
    };

_this.onOuterBlur = function (e) {
      if (_this.props.disabled) {
        e.preventDefault();
        return;
      }

_this.blurTimer = window.setTimeout(function () {
        _this._focused = false;

_this.updateFocusClassName();

var props = _this.props;
        var value = _this.state.value;
        var inputValue = _this.state.inputValue;

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["h" /* isSingleMode */])(props) && props.showSearch && inputValue && props.defaultActiveFirstOption) {
          var options = _this._options || [];

if (options.length) {
            var firstOption = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["i" /* findFirstMenuItem */])(options);

if (firstOption) {
              value = [__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(firstOption)];

_this.fireChange(value);
            }
          }
        } else if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(props) && inputValue) {
          if (_this._mouseDown) {
            // need update dropmenu when not blur
            _this.setInputValue('');
          } else {
            // why not use setState?
            // this.state.inputValue = '';
            _this.setState({
              inputValue: ''
            }, function () {
              if (_this.getInputDOMNode && _this.getInputDOMNode()) {
                _this.getInputDOMNode().value = '';
              }
            });
          }

var tmpValue = _this.getValueByInput(inputValue);

if (tmpValue !== undefined) {
            value = tmpValue;

_this.fireChange(value);
          }
        } // if click the rest space of Select in multiple mode

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(props) && _this._mouseDown) {
          _this.maybeFocus(true, true);

_this._mouseDown = false;
          return;
        }

_this.setOpenState(false);

if (props.onBlur) {
          props.onBlur(_this.getVLForOnChange(value));
        }
      }, 10);
    };

_this.onClearSelection = function (event) {
      var props = _this.props;
      var state = _this.state;

if (props.disabled) {
        return;
      }

var inputValue = state.inputValue;
      var value = state.value;
      event.stopPropagation();

if (inputValue || value.length) {
        if (value.length) {
          _this.fireChange([]);
        }

_this.setOpenState(false, true);

if (inputValue) {
          _this.setInputValue('');
        }
      }
    };

_this.onChoiceAnimationLeave = function () {
      _this.forcePopupAlign();
    };

_this.getOptionInfoBySingleValue = function (value, optionsInfo) {
      var info;
      optionsInfo = optionsInfo || _this.state.optionsInfo;

if (optionsInfo[__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["j" /* getMapKey */])(value)]) {
        info = optionsInfo[__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["j" /* getMapKey */])(value)];
      }

if (info) {
        return info;
      }

var defaultLabel = value;

if (_this.props.labelInValue) {
        var label = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["k" /* getLabelFromPropsValue */])(_this.props.value, value);

if (label !== undefined) {
          defaultLabel = label;
        }
      }

var defaultInfo = {
        option: __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_10__Option__["a" /* default */], {
          value: value,
          key: value
        }, value),
        value: value,
        label: defaultLabel
      };
      return defaultInfo;
    };

_this.getOptionBySingleValue = function (value) {
      var _this$getOptionInfoBy = _this.getOptionInfoBySingleValue(value),
          option = _this$getOptionInfoBy.option;

return option;
    };

_this.getOptionsBySingleValue = function (values) {
      return values.map(function (value) {
        return _this.getOptionBySingleValue(value);
      });
    };

_this.getValueByLabel = function (label) {
      if (label === undefined) {
        return null;
      }

var value = null;
      Object.keys(_this.state.optionsInfo).forEach(function (key) {
        var info = _this.state.optionsInfo[key];
        var oldLable = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["l" /* toArray */])(info.label);

if (oldLable && oldLable.join('') === label) {
          value = info.value;
        }
      });
      return value;
    };

_this.getVLBySingleValue = function (value) {
      if (_this.props.labelInValue) {
        return {
          key: value,
          label: _this.getLabelBySingleValue(value)
        };
      }

return value;
    };

_this.getVLForOnChange = function (vlsS) {
      var vls = vlsS;

if (vls !== undefined) {
        if (!_this.props.labelInValue) {
          vls = vls.map(function (v) {
            return v;
          });
        } else {
          vls = vls.map(function (vl) {
            return {
              key: vl,
              label: _this.getLabelBySingleValue(vl)
            };
          });
        }

return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(_this.props) ? vls : vls[0];
      }

return vls;
    };

_this.getLabelBySingleValue = function (value, optionsInfo) {
      var _this$getOptionInfoBy2 = _this.getOptionInfoBySingleValue(value, optionsInfo),
          label = _this$getOptionInfoBy2.label;

return label;
    };

_this.getDropdownContainer = function () {
      if (!_this.dropdownContainer) {
        _this.dropdownContainer = document.createElement('div');
        document.body.appendChild(_this.dropdownContainer);
      }

return _this.dropdownContainer;
    };

_this.getPlaceholderElement = function () {
      var props = _this.props;
      var state = _this.state;
      var hidden = false;

if (state.inputValue) {
        hidden = true;
      }

var value = state.value;

if (value.length) {
        hidden = true;
      }

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["c" /* isCombobox */])(props) && value.length === 1 && state.value && !state.value[0]) {
        hidden = false;
      }

var placeholder = props.placeholder;

if (placeholder) {
        return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("div", _extends({
          onMouseDown: __WEBPACK_IMPORTED_MODULE_13__util__["m" /* preventDefaultEvent */],
          style: _extends({
            display: hidden ? 'none' : 'block'
          }, __WEBPACK_IMPORTED_MODULE_13__util__["n" /* UNSELECTABLE_STYLE */])
        }, __WEBPACK_IMPORTED_MODULE_13__util__["o" /* UNSELECTABLE_ATTRIBUTE */], {
          onClick: _this.onPlaceholderClick,
          className: "".concat(props.prefixCls, "-selection__placeholder")
        }), placeholder);
      }

return null;
    };

_this.getInputElement = function () {
      var props = _this.props;
      var defaultInput = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("input", {
        id: props.id,
        autoComplete: "off"
      }); // tslint:disable-next-line:typedef-whitespace

var inputElement = props.getInputElement ? props.getInputElement() : defaultInput;
      var inputCls = __WEBPACK_IMPORTED_MODULE_0_classnames___default()(inputElement.props.className, _defineProperty({}, "".concat(props.prefixCls, "-search__field"), true)); // https://github.com/ant-design/ant-design/issues/4992#issuecomment-281542159
      // Add space to the end of the inputValue as the width measurement tolerance

return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("div", {
        className: "".concat(props.prefixCls, "-search__field__wrap")
      }, __WEBPACK_IMPORTED_MODULE_6_react__["cloneElement"](inputElement, {
        ref: _this.saveInputRef,
        onChange: _this.onInputChange,
        onKeyDown: chaining(_this.onInputKeyDown, inputElement.props.onKeyDown, _this.props.onInputKeyDown),
        value: _this.state.inputValue,
        disabled: props.disabled,
        className: inputCls
      }), __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("span", {
        ref: _this.saveInputMirrorRef,
        className: "".concat(props.prefixCls, "-search__field__mirror")
      }, _this.state.inputValue, "\xA0"));
    };

_this.getInputDOMNode = function () {
      return _this.topCtrlRef ? _this.topCtrlRef.querySelector('input,textarea,div[contentEditable]') : _this.inputRef;
    };

_this.getInputMirrorDOMNode = function () {
      return _this.inputMirrorRef;
    };

_this.getPopupDOMNode = function () {
      if (_this.selectTriggerRef) {
        return _this.selectTriggerRef.getPopupDOMNode();
      }
    };

_this.getPopupMenuComponent = function () {
      if (_this.selectTriggerRef) {
        return _this.selectTriggerRef.getInnerMenu();
      }
    };

_this.setOpenState = function (open, needFocus) {
      var props = _this.props;
      var state = _this.state;

if (state.open === open) {
        _this.maybeFocus(open, !!needFocus);

return;
      }

if (_this.props.onDropdownVisibleChange) {
        _this.props.onDropdownVisibleChange(open);
      }

var nextState = {
        open: open,
        backfillValue: ''
      }; // clear search input value when open is false in singleMode.

if (!open && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["h" /* isSingleMode */])(props) && props.showSearch) {
        _this.setInputValue('', false);
      }

if (!open) {
        _this.maybeFocus(open, !!needFocus);
      }

_this.setState(_extends({
        open: open
      }, nextState), function () {
        if (open) {
          _this.maybeFocus(open, !!needFocus);
        }
      });
    };

_this.setInputValue = function (inputValue) {
      var fireSearch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

if (inputValue !== _this.state.inputValue) {
        _this.setState({
          inputValue: inputValue
        }, _this.forcePopupAlign);

if (fireSearch && _this.props.onSearch) {
          _this.props.onSearch(inputValue);
        }
      }
    };

_this.getValueByInput = function (str) {
      var _this$props = _this.props,
          multiple = _this$props.multiple,
          tokenSeparators = _this$props.tokenSeparators;
      var nextValue = _this.state.value;
      var hasNewValue = false;
      __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["p" /* splitBySeparators */])(str, tokenSeparators).forEach(function (label) {
        var selectedValue = [label];

if (multiple) {
          var value = _this.getValueByLabel(label);

if (value && __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["e" /* findIndexInValueBySingleValue */])(nextValue, value) === -1) {
            nextValue = nextValue.concat(value);
            hasNewValue = true;

_this.fireSelect(value);
          }
        } else if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["e" /* findIndexInValueBySingleValue */])(nextValue, label) === -1) {
          nextValue = nextValue.concat(selectedValue);
          hasNewValue = true;

_this.fireSelect(label);
        }
      });
      return hasNewValue ? nextValue : undefined;
    };

_this.getRealOpenState = function (state) {
      // tslint:disable-next-line:variable-name
      var _open = _this.props.open;

if (typeof _open === 'boolean') {
        return _open;
      }

var open = (state || _this.state).open;
      var options = _this._options || [];

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["g" /* isMultipleOrTagsOrCombobox */])(_this.props) || !_this.props.showSearch) {
        if (open && !options.length) {
          open = false;
        }
      }

return open;
    };

_this.markMouseDown = function () {
      _this._mouseDown = true;
    };

_this.markMouseLeave = function () {
      _this._mouseDown = false;
    };

_this.handleBackfill = function (item) {
      if (!_this.props.backfill || !(__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["h" /* isSingleMode */])(_this.props) || __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["c" /* isCombobox */])(_this.props))) {
        return;
      }

var key = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(item);

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["c" /* isCombobox */])(_this.props)) {
        _this.setInputValue(key, false);
      }

_this.setState({
        value: [key],
        backfillValue: key
      });
    };

_this.filterOption = function (input, child) {
      var defaultFilter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : __WEBPACK_IMPORTED_MODULE_13__util__["q" /* defaultFilterFn */];
      var value = _this.state.value;
      var lastValue = value[value.length - 1];

if (!input || lastValue && lastValue === _this.state.backfillValue) {
        return true;
      }

var filterFn = _this.props.filterOption;

if ('filterOption' in _this.props) {
        if (filterFn === true) {
          filterFn = defaultFilter.bind(_assertThisInitialized(_assertThisInitialized(_this)));
        }
      } else {
        filterFn = defaultFilter.bind(_assertThisInitialized(_assertThisInitialized(_this)));
      }

if (!filterFn) {
        return true;
      } else if (typeof filterFn === 'function') {
        return filterFn.call(_assertThisInitialized(_assertThisInitialized(_this)), input, child);
      } else if (child.props.disabled) {
        return false;
      }

return true;
    };

_this.timeoutFocus = function () {
      if (_this.focusTimer) {
        _this.clearFocusTime();
      }

_this.focusTimer = window.setTimeout(function () {
        if (_this.props.onFocus) {
          _this.props.onFocus();
        }
      }, 10);
    };

_this.clearFocusTime = function () {
      if (_this.focusTimer) {
        clearTimeout(_this.focusTimer);
        _this.focusTimer = null;
      }
    };

_this.clearBlurTime = function () {
      if (_this.blurTimer) {
        clearTimeout(_this.blurTimer);
        _this.blurTimer = null;
      }
    };

_this.updateFocusClassName = function () {
      var rootRef = _this.rootRef;
      var props = _this.props; // avoid setState and its side effect

if (_this._focused) {
        __WEBPACK_IMPORTED_MODULE_1_component_classes___default()(rootRef).add("".concat(props.prefixCls, "-focused"));
      } else {
        __WEBPACK_IMPORTED_MODULE_1_component_classes___default()(rootRef).remove("".concat(props.prefixCls, "-focused"));
      }
    };

_this.maybeFocus = function (open, needFocus) {
      if (needFocus || open) {
        var input = _this.getInputDOMNode();

var _document = document,
            activeElement = _document.activeElement;

if (input && (open || __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["g" /* isMultipleOrTagsOrCombobox */])(_this.props))) {
          if (activeElement !== input) {
            input.focus();
            _this._focused = true;
          }
        } else if (activeElement !== _this.selectionRef && _this.selectionRef) {
          _this.selectionRef.focus();

_this._focused = true;
        }
      }
    };

_this.removeSelected = function (selectedKey, e) {
      var props = _this.props;

if (props.disabled || _this.isChildDisabled(selectedKey)) {
        return;
      } // Do not trigger Trigger popup

if (e && e.stopPropagation) {
        e.stopPropagation();
      }

var oldValue = _this.state.value;
      var value = oldValue.filter(function (singleValue) {
        return singleValue !== selectedKey;
      });
      var canMultiple = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(props);

if (canMultiple) {
        var event = selectedKey;

if (props.labelInValue) {
          event = {
            key: selectedKey,
            label: _this.getLabelBySingleValue(selectedKey)
          };
        }

if (props.onDeselect) {
          props.onDeselect(event, _this.getOptionBySingleValue(selectedKey));
        }
      }

_this.fireChange(value);
    };

_this.openIfHasChildren = function () {
      var props = _this.props;

if (__WEBPACK_IMPORTED_MODULE_6_react__["Children"].count(props.children) || __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["h" /* isSingleMode */])(props)) {
        _this.setOpenState(true);
      }
    };

_this.fireSelect = function (value) {
      if (_this.props.onSelect) {
        _this.props.onSelect(_this.getVLBySingleValue(value), _this.getOptionBySingleValue(value));
      }
    };

_this.fireChange = function (value) {
      var props = _this.props;

if (!('value' in props)) {
        _this.setState({
          value: value
        }, _this.forcePopupAlign);
      }

var vls = _this.getVLForOnChange(value);

var options = _this.getOptionsBySingleValue(value);

if (props.onChange) {
        props.onChange(vls, __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(_this.props) ? options : options[0]);
      }
    };

_this.isChildDisabled = function (key) {
      return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_4_rc_util_es_Children_toArray__["a" /* default */])(_this.props.children).some(function (child) {
        var childValue = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(child);
        return childValue === key && child.props && child.props.disabled;
      });
    };

_this.forcePopupAlign = function () {
      if (!_this.state.open) {
        return;
      }

if (_this.selectTriggerRef && _this.selectTriggerRef.triggerRef) {
        _this.selectTriggerRef.triggerRef.forcePopupAlign();
      }
    };

_this.renderFilterOptions = function () {
      var inputValue = _this.state.inputValue;
      var _this$props2 = _this.props,
          children = _this$props2.children,
          tags = _this$props2.tags,
          filterOption = _this$props2.filterOption,
          notFoundContent = _this$props2.notFoundContent;
      var menuItems = [];
      var childrenKeys = [];

var options = _this.renderFilterOptionsFromChildren(children, childrenKeys, menuItems);

if (tags) {
        // tags value must be string
        var value = _this.state.value;
        value = value.filter(function (singleValue) {
          return childrenKeys.indexOf(singleValue) === -1 && (!inputValue || String(singleValue).indexOf(String(inputValue)) > -1);
        });
        value.forEach(function (singleValue) {
          var key = singleValue;
          var menuItem = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_3_rc_menu__["a" /* Item */], {
            style: __WEBPACK_IMPORTED_MODULE_13__util__["n" /* UNSELECTABLE_STYLE */],
            role: "option",
            attribute: __WEBPACK_IMPORTED_MODULE_13__util__["o" /* UNSELECTABLE_ATTRIBUTE */],
            value: key,
            key: key
          }, key);
          options.push(menuItem);
          menuItems.push(menuItem);
        });

if (inputValue) {
          var notFindInputItem = menuItems.every(function (option) {
            // this.filterOption return true has two meaning,
            // 1, some one exists after filtering
            // 2, filterOption is set to false
            // condition 2 does not mean the option has same value with inputValue
            var filterFn = function filterFn() {
              return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(option) === inputValue;
            };

if (filterOption !== false) {
              return !_this.filterOption.call(_assertThisInitialized(_assertThisInitialized(_this)), inputValue, option, filterFn);
            }

return !filterFn();
          });

if (notFindInputItem) {
            options.unshift(__WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_3_rc_menu__["a" /* Item */], {
              style: __WEBPACK_IMPORTED_MODULE_13__util__["n" /* UNSELECTABLE_STYLE */],
              role: "option",
              attribute: __WEBPACK_IMPORTED_MODULE_13__util__["o" /* UNSELECTABLE_ATTRIBUTE */],
              value: inputValue,
              key: inputValue
            }, inputValue));
          }
        }
      }

if (!options.length && notFoundContent) {
        options = [__WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_3_rc_menu__["a" /* Item */], {
          style: __WEBPACK_IMPORTED_MODULE_13__util__["n" /* UNSELECTABLE_STYLE */],
          attribute: __WEBPACK_IMPORTED_MODULE_13__util__["o" /* UNSELECTABLE_ATTRIBUTE */],
          disabled: true,
          role: "option",
          value: "NOT_FOUND",
          key: "NOT_FOUND"
        }, notFoundContent)];
      }

return options;
    };

_this.renderFilterOptionsFromChildren = function (children, childrenKeys, menuItems) {
      var sel = [];
      var props = _this.props;
      var inputValue = _this.state.inputValue;
      var tags = props.tags;
      __WEBPACK_IMPORTED_MODULE_6_react__["Children"].forEach(children, function (child) {
        if (!child) {
          return;
        }

var type = child.type;

if (type.isSelectOptGroup) {
          var label = child.props.label;
          var key = child.key;

if (!key && typeof label === 'string') {
            key = label;
          } else if (!label && key) {
            label = key;
          } // Match option group label

if (inputValue && _this.filterOption(inputValue, child)) {
            var innerItems = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_4_rc_util_es_Children_toArray__["a" /* default */])(child.props.children).map(function (subChild) {
              var childValueSub = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(subChild) || subChild.key;
              return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_3_rc_menu__["a" /* Item */], _extends({
                key: childValueSub,
                value: childValueSub
              }, subChild.props));
            });
            sel.push(__WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_3_rc_menu__["b" /* ItemGroup */], {
              key: key,
              title: label
            }, innerItems)); // Not match
          } else {
            var _innerItems = _this.renderFilterOptionsFromChildren(child.props.children, childrenKeys, menuItems);

if (_innerItems.length) {
              sel.push(__WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_3_rc_menu__["b" /* ItemGroup */], {
                key: key,
                title: label
              }, _innerItems));
            }
          }

return;
        }

__WEBPACK_IMPORTED_MODULE_9_warning___default()(type.isSelectOption, 'the children of `Select` should be `Select.Option` or `Select.OptGroup`, ' + "instead of `".concat(type.name || type.displayName || child.type, "`."));
        var childValue = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(child);
        __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["r" /* validateOptionValue */])(childValue, _this.props);

if (_this.filterOption(inputValue, child)) {
          var menuItem = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_3_rc_menu__["a" /* Item */], _extends({
            style: __WEBPACK_IMPORTED_MODULE_13__util__["n" /* UNSELECTABLE_STYLE */],
            attribute: __WEBPACK_IMPORTED_MODULE_13__util__["o" /* UNSELECTABLE_ATTRIBUTE */],
            value: childValue,
            key: childValue,
            role: "option"
          }, child.props));
          sel.push(menuItem);
          menuItems.push(menuItem);
        }

if (tags) {
          childrenKeys.push(childValue);
        }
      });
      return sel;
    };

_this.renderTopControlNode = function () {
      var _this$state = _this.state,
          open = _this$state.open,
          inputValue = _this$state.inputValue;
      var value = _this.state.value;
      var props = _this.props;
      var choiceTransitionName = props.choiceTransitionName,
          prefixCls = props.prefixCls,
          maxTagTextLength = props.maxTagTextLength,
          maxTagCount = props.maxTagCount,
          showSearch = props.showSearch,
          removeIcon = props.removeIcon;
      var maxTagPlaceholder = props.maxTagPlaceholder;
      var className = "".concat(prefixCls, "-selection__rendered"); // search input is inside topControlNode in single, multiple & combobox. 2016/04/13

var innerNode = null;

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["h" /* isSingleMode */])(props)) {
        var selectedValue = null;

if (value.length) {
          var showSelectedValue = false;
          var opacity = 1;

if (!showSearch) {
            showSelectedValue = true;
          } else if (open) {
            showSelectedValue = !inputValue;

if (showSelectedValue) {
              opacity = 0.4;
            }
          } else {
            showSelectedValue = true;
          }

var singleValue = value[0];

var _this$getOptionInfoBy3 = _this.getOptionInfoBySingleValue(singleValue),
              label = _this$getOptionInfoBy3.label,
              title = _this$getOptionInfoBy3.title;

selectedValue = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("div", {
            key: "value",
            className: "".concat(prefixCls, "-selection-selected-value"),
            title: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["s" /* toTitle */])(title || label),
            style: {
              display: showSelectedValue ? 'block' : 'none',
              opacity: opacity
            }
          }, label);
        }

if (!showSearch) {
          innerNode = [selectedValue];
        } else {
          innerNode = [selectedValue, __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("div", {
            className: "".concat(prefixCls, "-search ").concat(prefixCls, "-search--inline"),
            key: "input",
            style: {
              display: open ? 'block' : 'none'
            }
          }, _this.getInputElement())];
        }
      } else {
        var selectedValueNodes = [];
        var limitedCountValue = value;
        var maxTagPlaceholderEl;

if (maxTagCount !== undefined && value.length > maxTagCount) {
          limitedCountValue = limitedCountValue.slice(0, maxTagCount);

var omittedValues = _this.getVLForOnChange(value.slice(maxTagCount, value.length));

var content = "+ ".concat(value.length - maxTagCount, " ...");

if (maxTagPlaceholder) {
            content = typeof maxTagPlaceholder === 'function' ? maxTagPlaceholder(omittedValues) : maxTagPlaceholder;
          }

maxTagPlaceholderEl = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("li", _extends({
            style: __WEBPACK_IMPORTED_MODULE_13__util__["n" /* UNSELECTABLE_STYLE */]
          }, __WEBPACK_IMPORTED_MODULE_13__util__["o" /* UNSELECTABLE_ATTRIBUTE */], {
            role: "presentation",
            onMouseDown: __WEBPACK_IMPORTED_MODULE_13__util__["m" /* preventDefaultEvent */],
            className: "".concat(prefixCls, "-selection__choice ").concat(prefixCls, "-selection__choice__disabled"),
            key: "maxTagPlaceholder",
            title: __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["s" /* toTitle */])(content)
          }), __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("div", {
            className: "".concat(prefixCls, "-selection__choice__content")
          }, content));
        }

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(props)) {
          selectedValueNodes = limitedCountValue.map(function (singleValue) {
            var info = _this.getOptionInfoBySingleValue(singleValue);

var content = info.label;
            var title = info.title || content;

if (maxTagTextLength && typeof content === 'string' && content.length > maxTagTextLength) {
              content = "".concat(content.slice(0, maxTagTextLength), "...");
            }

var disabled = _this.isChildDisabled(singleValue);

if (maxTagPlaceholderEl) {
          selectedValueNodes.push(maxTagPlaceholderEl);
        }

selectedValueNodes.push(__WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("li", {
          className: "".concat(prefixCls, "-search ").concat(prefixCls, "-search--inline"),
          key: "__input"
        }, _this.getInputElement()));

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(props) && choiceTransitionName) {
          innerNode = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"](__WEBPACK_IMPORTED_MODULE_2_rc_animate__["a" /* default */], {
            onLeave: _this.onChoiceAnimationLeave,
            component: "ul",
            transitionName: choiceTransitionName
          }, selectedValueNodes);
        } else {
          innerNode = __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("ul", null, selectedValueNodes);
        }
      }

return __WEBPACK_IMPORTED_MODULE_6_react__["createElement"]("div", {
        className: className,
        ref: _this.saveTopCtrlRef
      }, _this.getPlaceholderElement(), innerNode);
    };

var optionsInfo = Select.getOptionsInfoFromProps(props);
    _this.state = {
      value: Select.getValueFromProps(props, true),
      inputValue: props.combobox ? Select.getInputValueForCombobox(props, optionsInfo, true) : '',
      open: props.defaultOpen,
      optionsInfo: optionsInfo,
      backfillValue: '',
      // a flag for aviod redundant getOptionsInfoFromProps call
      skipBuildOptionsInfo: true
    };
    _this.saveInputRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'inputRef');
    _this.saveInputMirrorRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'inputMirrorRef');
    _this.saveTopCtrlRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'topCtrlRef');
    _this.saveSelectTriggerRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'selectTriggerRef');
    _this.saveRootRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'rootRef');
    _this.saveSelectionRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'selectionRef');
    _this.ariaId = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["u" /* generateUUID */])();
    return _this;
  }

_createClass(Select, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      if (this.props.autoFocus) {
        this.focus();
      }
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate() {
      if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(this.props)) {
        var inputNode = this.getInputDOMNode();
        var mirrorNode = this.getInputMirrorDOMNode();

if (inputNode && inputNode.value && mirrorNode) {
          inputNode.style.width = '';
          inputNode.style.width = "".concat(mirrorNode.clientWidth, "px");
        } else if (inputNode) {
          inputNode.style.width = '';
        }
      }

this.forcePopupAlign();
    }
  }, {
    key: "componentWillUnmount",
    value: function componentWillUnmount() {
      this.clearFocusTime();
      this.clearBlurTime();

if (this.dropdownContainer) {
        __WEBPACK_IMPORTED_MODULE_7_react_dom__["unmountComponentAtNode"](this.dropdownContainer);
        document.body.removeChild(this.dropdownContainer);
        this.dropdownContainer = null;
      }
    }
  }, {
    key: "focus",
    value: function focus() {
      if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["h" /* isSingleMode */])(this.props) && this.selectionRef) {
        this.selectionRef.focus();
      } else if (this.getInputDOMNode()) {
        this.getInputDOMNode().focus();
      }
    }
  }, {
    key: "blur",
    value: function blur() {
      if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["h" /* isSingleMode */])(this.props) && this.selectionRef) {
        this.selectionRef.blur();
      } else if (this.getInputDOMNode()) {
        this.getInputDOMNode().blur();
      }
    }
  }, {
    key: "renderArrow",
    value: function renderArrow(multiple) {
      var _this$props3 = this.props,
          showArrow = _this$props3.showArrow,
          loading = _this$props3.loading,
          inputIcon = _this$props3.inputIcon,
          prefixCls = _this$props3.prefixCls;

if (!showArrow) {
        return null;
      } // if loading  have loading icon

if (multiple && !loading) {
        return null;
      }

if (!allowClear) {
        return null;
      }

if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["c" /* isCombobox */])(this.props)) {
        if (inputValue) {
          return clear;
        }

return null;
      }

if (inputValue || value.length) {
        return clear;
      }

return null;
    }
  }, {
    key: "render",
    value: function render() {
      var _rootCls;

var props = this.props;
      var multiple = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["a" /* isMultipleOrTags */])(props);
      var state = this.state;
      var className = props.className,
          disabled = props.disabled,
          prefixCls = props.prefixCls;
      var ctrlNode = this.renderTopControlNode();
      var open = this.state.open;

if (open) {
        this._options = this.renderFilterOptions();
      }

var extraSelectionProps = _extends({}, dataOrAriaAttributeProps);

if (!__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["g" /* isMultipleOrTagsOrCombobox */])(props)) {
        extraSelectionProps = _extends({}, extraSelectionProps, {
          onKeyDown: this.onKeyDown,
          tabIndex: props.disabled ? -1 : props.tabIndex
        });
      }

return Select;
}(__WEBPACK_IMPORTED_MODULE_6_react__["Component"]);

Select.propTypes = __WEBPACK_IMPORTED_MODULE_11__PropTypes__["a" /* default */];
Select.defaultProps = {
  prefixCls: 'rc-select',
  defaultOpen: false,
  labelInValue: false,
  defaultActiveFirstOption: true,
  showSearch: true,
  allowClear: false,
  placeholder: '',
  onChange: noop,
  onFocus: noop,
  onBlur: noop,
  onSelect: noop,
  onSearch: noop,
  onDeselect: noop,
  onInputKeyDown: noop,
  showArrow: true,
  dropdownMatchSelectWidth: true,
  dropdownStyle: {},
  dropdownMenuStyle: {},
  optionFilterProp: 'value',
  optionLabelProp: 'value',
  notFoundContent: 'Not Found',
  backfill: false,
  showAction: ['click'],
  tokenSeparators: [],
  autoClearSearchValue: true,
  tabIndex: 0,
  dropdownRender: function dropdownRender(menu) {
    return menu;
  }
};

Select.getDerivedStateFromProps = function (nextProps, prevState) {
  var optionsInfo = prevState.skipBuildOptionsInfo ? prevState.optionsInfo : Select.getOptionsInfoFromProps(nextProps, prevState);
  var newState = {
    optionsInfo: optionsInfo,
    skipBuildOptionsInfo: false
  };

if ('open' in nextProps) {
    newState.open = nextProps.open;
  }

if ('value' in nextProps) {
    var value = Select.getValueFromProps(nextProps);
    newState.value = value;

if (nextProps.combobox) {
      newState.inputValue = Select.getInputValueForCombobox(nextProps, optionsInfo);
    }
  }

return newState;
};

Select.getOptionsFromChildren = function (children) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  __WEBPACK_IMPORTED_MODULE_6_react__["Children"].forEach(children, function (child) {
    if (!child) {
      return;
    }

var type = child.type;

if (type.isSelectOptGroup) {
      Select.getOptionsFromChildren(child.props.children, options);
    } else {
      options.push(child);
    }
  });
  return options;
};

Select.getInputValueForCombobox = function (props, optionsInfo, useDefaultValue) {
  var value = [];

if ('value' in props && !useDefaultValue) {
    value = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["l" /* toArray */])(props.value);
  }

if ('defaultValue' in props && useDefaultValue) {
    value = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["l" /* toArray */])(props.defaultValue);
  }

if (value.length) {
    value = value[0];
  } else {
    return '';
  }

var label = value;

if (props.labelInValue) {
    label = value.label;
  } else if (optionsInfo[__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["j" /* getMapKey */])(value)]) {
    label = optionsInfo[__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["j" /* getMapKey */])(value)].label;
  }

if (label === undefined) {
    label = '';
  }

return label;
};

Select.getLabelFromOption = function (props, option) {
  return __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["f" /* getPropValue */])(option, props.optionLabelProp);
};

Select.getOptionsInfoFromProps = function (props, preState) {
  var options = Select.getOptionsFromChildren(props.children);
  var optionsInfo = {};
  options.forEach(function (option) {
    var singleValue = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["d" /* getValuePropValue */])(option);
    optionsInfo[__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["j" /* getMapKey */])(singleValue)] = {
      option: option,
      value: singleValue,
      label: Select.getLabelFromOption(props, option),
      title: option.props.title
    };
  });

if (preState) {
    // keep option info in pre state value.
    var oldOptionsInfo = preState.optionsInfo;
    var value = preState.value;

if (value) {
      value.forEach(function (v) {
        var key = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["j" /* getMapKey */])(v);

if (!optionsInfo[key] && oldOptionsInfo[key] !== undefined) {
          optionsInfo[key] = oldOptionsInfo[key];
        }
      });
    }
  }

return optionsInfo;
};

Select.getValueFromProps = function (props, useDefaultValue) {
  var value = [];

if ('value' in props && !useDefaultValue) {
    value = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["l" /* toArray */])(props.value);
  }

if ('defaultValue' in props && useDefaultValue) {
    value = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_13__util__["l" /* toArray */])(props.defaultValue);
  }

if (props.labelInValue) {
    value = value.map(function (v) {
      return v.key;
    });
  }

return value;
};

Select.displayName = 'Select';
__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_8_react_lifecycles_compat__["polyfill"])(Select);
/* harmony default export */ __webpack_exports__["a"] = (Select);

/***/ }),
/* 1152 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return SelectTrigger; });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_rc_trigger__ = __webpack_require__(301);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__DropdownMenu__ = __webpack_require__(1149);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__util__ = __webpack_require__(299);
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

var __rest = this && this.__rest || function (s, e) {
  var t = {};

for (var p in s) {
    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
  }

if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
    if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
  }
  return t;
};

__WEBPACK_IMPORTED_MODULE_2_rc_trigger__["a" /* default */].displayName = 'Trigger';
var BUILT_IN_PLACEMENTS = {
  bottomLeft: {
    points: ['tl', 'bl'],
    offset: [0, 4],
    overflow: {
      adjustX: 0,
      adjustY: 1
    }
  },
  topLeft: {
    points: ['bl', 'tl'],
    offset: [0, -4],
    overflow: {
      adjustX: 0,
      adjustY: 1
    }
  }
};

var SelectTrigger =
/*#__PURE__*/
function (_React$Component) {
  _inherits(SelectTrigger, _React$Component);

function SelectTrigger(props) {
    var _this;

_classCallCheck(this, SelectTrigger);

_this = _possibleConstructorReturn(this, _getPrototypeOf(SelectTrigger).call(this, props));
    _this.dropdownMenuRef = null;

_this.setDropdownWidth = function () {
      var dom = __WEBPACK_IMPORTED_MODULE_4_react_dom__["findDOMNode"](_assertThisInitialized(_assertThisInitialized(_this)));
      var width = dom.offsetWidth;

if (width !== _this.state.dropdownWidth) {
        _this.setState({
          dropdownWidth: width
        });
      }
    };

_this.getInnerMenu = function () {
      return _this.dropdownMenuRef && _this.dropdownMenuRef.menuRef;
    };

_this.getPopupDOMNode = function () {
      return _this.triggerRef.getPopupDomNode();
    };

_this.getDropdownElement = function (newProps) {
      var props = _this.props;
      var dropdownRender = props.dropdownRender,
          ariaId = props.ariaId;
      var menuNode = __WEBPACK_IMPORTED_MODULE_3_react__["createElement"](__WEBPACK_IMPORTED_MODULE_5__DropdownMenu__["a" /* default */], _extends({
        ref: _this.saveDropdownMenuRef
      }, newProps, {
        ariaId: ariaId,
        prefixCls: _this.getDropdownPrefixCls(),
        onMenuSelect: props.onMenuSelect,
        onMenuDeselect: props.onMenuDeselect,
        onPopupScroll: props.onPopupScroll,
        value: props.value,
        backfillValue: props.backfillValue,
        firstActiveValue: props.firstActiveValue,
        defaultActiveFirstOption: props.defaultActiveFirstOption,
        dropdownMenuStyle: props.dropdownMenuStyle,
        menuItemSelectedIcon: props.menuItemSelectedIcon
      }));

if (dropdownRender) {
        return dropdownRender(menuNode, props);
      }

return null;
    };

_this.getDropdownTransitionName = function () {
      var props = _this.props;
      var transitionName = props.transitionName;

if (!transitionName && props.animation) {
        transitionName = "".concat(_this.getDropdownPrefixCls(), "-").concat(props.animation);
      }

return transitionName;
    };

_this.getDropdownPrefixCls = function () {
      return "".concat(_this.props.prefixCls, "-dropdown");
    };

_this.saveDropdownMenuRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'dropdownMenuRef');
    _this.saveTriggerRef = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6__util__["t" /* saveRef */])(_assertThisInitialized(_assertThisInitialized(_this)), 'triggerRef');
    _this.state = {
      dropdownWidth: 0
    };
    return _this;
  }

_createClass(SelectTrigger, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      this.setDropdownWidth();
    }
  }, {
    key: "componentDidUpdate",
    value: function componentDidUpdate() {
      this.setDropdownWidth();
    }
  }, {
    key: "render",
    value: function render() {
      var _popupClassName;

var _a = this.props,
          onPopupFocus = _a.onPopupFocus,
          props = __rest(_a, ["onPopupFocus"]);

var multiple = props.multiple,
          visible = props.visible,
          inputValue = props.inputValue,
          dropdownAlign = props.dropdownAlign,
          disabled = props.disabled,
          showSearch = props.showSearch,
          dropdownClassName = props.dropdownClassName,
          dropdownStyle = props.dropdownStyle,
          dropdownMatchSelectWidth = props.dropdownMatchSelectWidth;
      var dropdownPrefixCls = this.getDropdownPrefixCls();
      var popupClassName = (_popupClassName = {}, _defineProperty(_popupClassName, dropdownClassName, !!dropdownClassName), _defineProperty(_popupClassName, "".concat(dropdownPrefixCls, "--").concat(multiple ? 'multiple' : 'single'), 1), _popupClassName);
      var popupElement = this.getDropdownElement({
        menuItems: props.options,
        onPopupFocus: onPopupFocus,
        multiple: multiple,
        inputValue: inputValue,
        visible: visible
      });
      var hideAction;

if (disabled) {
        hideAction = [];
      } else if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_6__util__["h" /* isSingleMode */])(props) && !showSearch) {
        hideAction = ['click'];
      } else {
        hideAction = ['blur'];
      }

var popupStyle = _extends({}, dropdownStyle);

var widthProp = dropdownMatchSelectWidth ? 'width' : 'minWidth';

if (this.state.dropdownWidth) {
        popupStyle[widthProp] = "".concat(this.state.dropdownWidth, "px");
      }

return __WEBPACK_IMPORTED_MODULE_3_react__["createElement"](__WEBPACK_IMPORTED_MODULE_2_rc_trigger__["a" /* default */], _extends({}, props, {
        showAction: disabled ? [] : this.props.showAction,
        hideAction: hideAction,
        ref: this.saveTriggerRef,
        popupPlacement: "bottomLeft",
        builtinPlacements: BUILT_IN_PLACEMENTS,
        prefixCls: dropdownPrefixCls,
        popupTransitionName: this.getDropdownTransitionName(),
        onPopupVisibleChange: props.onDropdownVisibleChange,
        popup: popupElement,
        popupAlign: dropdownAlign,
        popupVisible: visible,
        getPopupContainer: props.getPopupContainer,
        popupClassName: __WEBPACK_IMPORTED_MODULE_0_classnames___default()(popupClassName),
        popupStyle: popupStyle
      }), props.children);
    }
  }]);

return SelectTrigger;
}(__WEBPACK_IMPORTED_MODULE_3_react__["Component"]);

SelectTrigger.defaultProps = {
  dropdownRender: function dropdownRender(menu) {
    return menu;
  }
};
SelectTrigger.propTypes = {
  onPopupFocus: __WEBPACK_IMPORTED_MODULE_1_prop_types__["func"],
  onPopupScroll: __WEBPACK_IMPORTED_MODULE_1_prop_types__["func"],
  dropdownMatchSelectWidth: __WEBPACK_IMPORTED_MODULE_1_prop_types__["bool"],
  dropdownAlign: __WEBPACK_IMPORTED_MODULE_1_prop_types__["object"],
  visible: __WEBPACK_IMPORTED_MODULE_1_prop_types__["bool"],
  disabled: __WEBPACK_IMPORTED_MODULE_1_prop_types__["bool"],
  showSearch: __WEBPACK_IMPORTED_MODULE_1_prop_types__["bool"],
  dropdownClassName: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"],
  multiple: __WEBPACK_IMPORTED_MODULE_1_prop_types__["bool"],
  inputValue: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"],
  filterOption: __WEBPACK_IMPORTED_MODULE_1_prop_types__["any"],
  options: __WEBPACK_IMPORTED_MODULE_1_prop_types__["any"],
  prefixCls: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"],
  popupClassName: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"],
  children: __WEBPACK_IMPORTED_MODULE_1_prop_types__["any"],
  showAction: __WEBPACK_IMPORTED_MODULE_1_prop_types__["arrayOf"](__WEBPACK_IMPORTED_MODULE_1_prop_types__["string"]),
  menuItemSelectedIcon: __WEBPACK_IMPORTED_MODULE_1_prop_types__["oneOfType"]([__WEBPACK_IMPORTED_MODULE_1_prop_types__["func"], __WEBPACK_IMPORTED_MODULE_1_prop_types__["node"]]),
  dropdownRender: __WEBPACK_IMPORTED_MODULE_1_prop_types__["func"],
  ariaId: __WEBPACK_IMPORTED_MODULE_1_prop_types__["string"]
};
SelectTrigger.displayName = 'SelectTrigger';

/***/ }),
/* 1153 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_toConsumableArray__ = __webpack_require__(160);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_toConsumableArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_toConsumableArray__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames__ = __webpack_require__(9);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_classnames__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_shallowequal__ = __webpack_require__(115);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10_shallowequal___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_10_shallowequal__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__common_Track__ = __webpack_require__(475);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__common_createSlider__ = __webpack_require__(476);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__utils__ = __webpack_require__(300);

/* eslint-disable react/prop-types */

var Range = function (_React$Component) {
  __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default()(Range, _React$Component);

function Range(props) {
    __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default()(this, Range);

var _this = __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Range.__proto__ || Object.getPrototypeOf(Range)).call(this, props));

_this.onEnd = function (force) {
      var handle = _this.state.handle;

_this.removeDocumentEvents();

if (handle !== null || force) {
        _this.props.onAfterChange(_this.getValue());
      }

_this.setState({
        handle: null
      });
    };

var count = props.count,
        min = props.min,
        max = props.max;

var initialValue = Array.apply(undefined, __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_toConsumableArray___default()(Array(count + 1))).map(function () {
      return min;
    });
    var defaultValue = 'defaultValue' in props ? props.defaultValue : initialValue;
    var value = props.value !== undefined ? props.value : defaultValue;
    var bounds = value.map(function (v, i) {
      return _this.trimAlignValue(v, i);
    });
    var recent = bounds[0] === max ? 0 : bounds.length - 1;

_this.state = {
      handle: null,
      recent: recent,
      bounds: bounds
    };
    return _this;
  }

__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default()(Range, [{
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      var _this2 = this;

if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;
      if (this.props.min === nextProps.min && this.props.max === nextProps.max && __WEBPACK_IMPORTED_MODULE_10_shallowequal___default()(this.props.value, nextProps.value)) {
        return;
      }

var bounds = this.state.bounds;

var value = nextProps.value || bounds;
      var nextBounds = value.map(function (v, i) {
        return _this2.trimAlignValue(v, i, nextProps);
      });
      if (nextBounds.length === bounds.length && nextBounds.every(function (v, i) {
        return v === bounds[i];
      })) return;

this.setState({ bounds: nextBounds });

if (value.some(function (v) {
        return __WEBPACK_IMPORTED_MODULE_13__utils__["b" /* isValueOutOfRange */](v, nextProps);
      })) {
        var newValues = value.map(function (v) {
          return __WEBPACK_IMPORTED_MODULE_13__utils__["e" /* ensureValueInRange */](v, nextProps);
        });
        this.props.onChange(newValues);
      }
    }
  }, {
    key: 'onChange',
    value: function onChange(state) {
      var props = this.props;
      var isNotControlled = !('value' in props);
      if (isNotControlled) {
        this.setState(state);
      } else {
        var controlledState = {};

['handle', 'recent'].forEach(function (item) {
          if (state[item] !== undefined) {
            controlledState[item] = state[item];
          }
        });

if (Object.keys(controlledState).length) {
          this.setState(controlledState);
        }
      }

var value = this.calcValueByPos(position);
      this.startValue = value;
      this.startPosition = position;

var closestBound = this.getClosestBound(value);
      this.prevMovedHandleIndex = this.getBoundNeedMoving(value, closestBound);

this.setState({
        handle: this.prevMovedHandleIndex,
        recent: this.prevMovedHandleIndex
      });

var prevValue = bounds[this.prevMovedHandleIndex];
      if (value === prevValue) return;

var value = this.calcValueByPos(position);
      var oldValue = state.bounds[state.handle];
      if (value === oldValue) return;

this.moveTo(value);
    }
  }, {
    key: 'onKeyboard',
    value: function onKeyboard(e) {
      var valueMutator = __WEBPACK_IMPORTED_MODULE_13__utils__["d" /* getKeyboardValueMutator */](e);

if (valueMutator) {
        __WEBPACK_IMPORTED_MODULE_13__utils__["c" /* pauseEvent */](e);
        var state = this.state,
            props = this.props;
        var bounds = state.bounds,
            handle = state.handle;

var boundNeedMoving = closestBound;
      var isAtTheSamePoint = bounds[closestBound + 1] === bounds[closestBound];

if (isAtTheSamePoint && bounds[recent] === bounds[closestBound]) {
        boundNeedMoving = recent;
      }

if (isAtTheSamePoint && value !== bounds[closestBound + 1]) {
        boundNeedMoving = value < bounds[closestBound + 1] ? closestBound : closestBound + 1;
      }
      return boundNeedMoving;
    }
  }, {
    key: 'getLowerBound',
    value: function getLowerBound() {
      return this.state.bounds[0];
    }
  }, {
    key: 'getUpperBound',
    value: function getUpperBound() {
      var bounds = this.state.bounds;

return bounds[bounds.length - 1];
    }

/**
     * Returns an array of possible slider points, taking into account both
     * `marks` and `step`. The result is cached.
     */

}, {
    key: 'getPoints',
    value: function getPoints() {
      var _props = this.props,
          marks = _props.marks,
          step = _props.step,
          min = _props.min,
          max = _props.max;

var state = this.state,
          props = this.props;

threshold = Number(threshold);

var direction = 0;
      if (bounds[handle + 1] - value < threshold) {
        direction = +1; // push to right
      }
      if (value - bounds[handle - 1] < threshold) {
        direction = -1; // push to left
      }

if (direction === 0) {
        return;
      }

var state = this.state || {};
      var bounds = state.bounds;

handle = handle === undefined ? state.handle : handle;
      thershold = Number(thershold);
      /* eslint-disable eqeqeq */
      if (!allowCross && handle != null && bounds !== undefined) {
        if (handle > 0 && val <= bounds[handle - 1] + thershold) {
          return bounds[handle - 1] + thershold;
        }
        if (handle < bounds.length - 1 && val >= bounds[handle + 1] - thershold) {
          return bounds[handle + 1] - thershold;
        }
      }
      /* eslint-enable eqeqeq */
      return val;
    }
  }, {
    key: 'render',
    value: function render() {
      var _this4 = this;

var _state2 = this.state,
          handle = _state2.handle,
          bounds = _state2.bounds;
      var _props2 = this.props,
          prefixCls = _props2.prefixCls,
          vertical = _props2.vertical,
          included = _props2.included,
          disabled = _props2.disabled,
          min = _props2.min,
          max = _props2.max,
          handleGenerator = _props2.handle,
          trackStyle = _props2.trackStyle,
          handleStyle = _props2.handleStyle,
          tabIndex = _props2.tabIndex;

var offsets = bounds.map(function (v) {
        return _this4.calcOffset(v);
      });

var handleClassName = prefixCls + '-handle';
      var handles = bounds.map(function (v, i) {
        var _classNames;

var tracks = bounds.slice(0, -1).map(function (_, index) {
        var _classNames2;

var i = index + 1;
        var trackClassName = __WEBPACK_IMPORTED_MODULE_9_classnames___default()((_classNames2 = {}, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_classNames2, prefixCls + '-track', true), __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_classNames2, prefixCls + '-track-' + i, true), _classNames2));
        return __WEBPACK_IMPORTED_MODULE_7_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_11__common_Track__["a" /* default */], {
          className: trackClassName,
          vertical: vertical,
          included: included,
          offset: offsets[i - 1],
          length: offsets[i] - offsets[i - 1],
          style: trackStyle[index],
          key: i
        });
      });

return { tracks: tracks, handles: handles };
    }
  }]);

return Range;
}(__WEBPACK_IMPORTED_MODULE_7_react___default.a.Component);

Range.displayName = 'Range';
Range.propTypes = {
  autoFocus: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  defaultValue: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number),
  value: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number),
  count: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number,
  pushable: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number]),
  allowCross: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  disabled: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  tabIndex: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number),
  min: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number,
  max: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number
};
Range.defaultProps = {
  count: 1,
  allowCross: true,
  pushable: false,
  tabIndex: []
};

/* harmony default export */ __webpack_exports__["a"] = (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_12__common_createSlider__["a" /* default */])(Range));

/***/ }),
/* 1154 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_warning__ = __webpack_require__(117);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_warning___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_warning__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__common_Track__ = __webpack_require__(475);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__common_createSlider__ = __webpack_require__(476);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__utils__ = __webpack_require__(300);

/* eslint-disable react/prop-types */

var Slider = function (_React$Component) {
  __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(Slider, _React$Component);

function Slider(props) {
    __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, Slider);

var _this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Slider.__proto__ || Object.getPrototypeOf(Slider)).call(this, props));

_this.onEnd = function (force) {
      var dragging = _this.state.dragging;

_this.removeDocumentEvents();
      if (dragging || force) {
        _this.props.onAfterChange(_this.getValue());
      }
      _this.setState({ dragging: false });
    };

var defaultValue = props.defaultValue !== undefined ? props.defaultValue : props.min;
    var value = props.value !== undefined ? props.value : defaultValue;

_this.state = {
      value: _this.trimAlignValue(value),
      dragging: false
    };
    if (__WEBPACK_IMPORTED_MODULE_10__utils__["a" /* isDev */]()) {
      __WEBPACK_IMPORTED_MODULE_7_warning___default()(!('minimumTrackStyle' in props), 'minimumTrackStyle will be deprecated, please use trackStyle instead.');
      __WEBPACK_IMPORTED_MODULE_7_warning___default()(!('maximumTrackStyle' in props), 'maximumTrackStyle will be deprecated, please use railStyle instead.');
    }
    return _this;
  }

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_createClass___default()(Slider, [{
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;

var prevValue = this.state.value;
      var value = nextProps.value !== undefined ? nextProps.value : prevValue;
      var nextValue = this.trimAlignValue(value, nextProps);
      if (nextValue === prevValue) return;

this.setState({ value: nextValue });
      if (__WEBPACK_IMPORTED_MODULE_10__utils__["b" /* isValueOutOfRange */](value, nextProps)) {
        this.props.onChange(nextValue);
      }
    }
  }, {
    key: 'onChange',
    value: function onChange(state) {
      var props = this.props;
      var isNotControlled = !('value' in props);
      var nextState = state.value > this.props.max ? __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, state, { value: this.props.max }) : state;
      if (isNotControlled) {
        this.setState(nextState);
      }

var value = this.calcValueByPos(position);
      this.startValue = value;
      this.startPosition = position;

if (value === prevValue) return;

this.prevMovedHandleIndex = 0;

this.onChange({ value: value });
    }
  }, {
    key: 'onMove',
    value: function onMove(e, position) {
      __WEBPACK_IMPORTED_MODULE_10__utils__["c" /* pauseEvent */](e);
      var oldValue = this.state.value;

var value = this.calcValueByPos(position);
      if (value === oldValue) return;

this.onChange({ value: value });
    }
  }, {
    key: 'onKeyboard',
    value: function onKeyboard(e) {
      var valueMutator = __WEBPACK_IMPORTED_MODULE_10__utils__["d" /* getKeyboardValueMutator */](e);

if (valueMutator) {
        __WEBPACK_IMPORTED_MODULE_10__utils__["c" /* pauseEvent */](e);
        var state = this.state;
        var oldValue = state.value;
        var mutatedValue = valueMutator(oldValue, this.props);
        var value = this.trimAlignValue(mutatedValue);
        if (value === oldValue) return;

this.onChange({ value: value });
        this.props.onAfterChange(value);
        this.onEnd();
      }
    }
  }, {
    key: 'getValue',
    value: function getValue() {
      return this.state.value;
    }
  }, {
    key: 'getLowerBound',
    value: function getLowerBound() {
      return this.props.min;
    }
  }, {
    key: 'getUpperBound',
    value: function getUpperBound() {
      return this.state.value;
    }
  }, {
    key: 'trimAlignValue',
    value: function trimAlignValue(v) {
      var nextProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

if (v === null) {
        return null;
      }

var _props = this.props,
          prefixCls = _props.prefixCls,
          vertical = _props.vertical,
          included = _props.included,
          disabled = _props.disabled,
          minimumTrackStyle = _props.minimumTrackStyle,
          trackStyle = _props.trackStyle,
          handleStyle = _props.handleStyle,
          tabIndex = _props.tabIndex,
          min = _props.min,
          max = _props.max,
          handleGenerator = _props.handle;
      var _state = this.state,
          value = _state.value,
          dragging = _state.dragging;

var offset = this.calcOffset(value);
      var handle = handleGenerator({
        className: prefixCls + '-handle',
        prefixCls: prefixCls,
        vertical: vertical,
        offset: offset,
        value: value,
        dragging: dragging,
        disabled: disabled,
        min: min,
        max: max,
        index: 0,
        tabIndex: tabIndex,
        style: handleStyle[0] || handleStyle,
        ref: function ref(h) {
          return _this2.saveHandle(0, h);
        }
      });

var _trackStyle = trackStyle[0] || trackStyle;
      var track = __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_8__common_Track__["a" /* default */], {
        className: prefixCls + '-track',
        vertical: vertical,
        included: included,
        offset: 0,
        length: offset,
        style: __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, minimumTrackStyle, _trackStyle)
      });

return { tracks: track, handles: handle };
    }
  }]);

return Slider;
}(__WEBPACK_IMPORTED_MODULE_5_react___default.a.Component);

Slider.propTypes = {
  defaultValue: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  value: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  disabled: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  autoFocus: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  tabIndex: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  min: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  max: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number
};

/* harmony default export */ __webpack_exports__["a"] = (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_9__common_createSlider__["a" /* default */])(Slider));

/***/ }),
/* 1155 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var Marks = function Marks(_ref) {
  var className = _ref.className,
      vertical = _ref.vertical,
      marks = _ref.marks,
      included = _ref.included,
      upperBound = _ref.upperBound,
      lowerBound = _ref.lowerBound,
      max = _ref.max,
      min = _ref.min,
      onClickLabel = _ref.onClickLabel;

var marksKeys = Object.keys(marks);

var range = max - min;
  var elements = marksKeys.map(parseFloat).sort(function (a, b) {
    return a - b;
  }).map(function (point) {
    var _classNames;

var markPoint = marks[point];
    var markPointIsObject = typeof markPoint === 'object' && !__WEBPACK_IMPORTED_MODULE_2_react___default.a.isValidElement(markPoint);
    var markLabel = markPointIsObject ? markPoint.label : markPoint;
    if (!markLabel && markLabel !== 0) {
      return null;
    }

var isActive = !included && point === upperBound || included && point <= upperBound && point >= lowerBound;
    var markClassName = __WEBPACK_IMPORTED_MODULE_4_classnames___default()((_classNames = {}, __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, className + '-text', true), __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default()(_classNames, className + '-text-active', isActive), _classNames));

var bottomStyle = {
      marginBottom: '-50%',
      bottom: (point - min) / range * 100 + '%'
    };

var leftStyle = {
      left: (point - min) / range * 100 + '%',
      transform: 'translateX(-50%)',
      msTransform: 'translateX(-50%)'
    };

return __WEBPACK_IMPORTED_MODULE_2_react___default.a.createElement(
    'div',
    { className: className },
    elements
  );
};

Marks.propTypes = {
  className: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.string,
  vertical: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.bool,
  marks: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object,
  included: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.bool,
  upperBound: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  lowerBound: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  max: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  min: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  onClickLabel: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.func
};

/* harmony default export */ __webpack_exports__["a"] = (Marks);

/***/ }),
/* 1156 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var Steps = function Steps(_ref) {
  var prefixCls = _ref.prefixCls,
      vertical = _ref.vertical,
      marks = _ref.marks,
      dots = _ref.dots,
      step = _ref.step,
      included = _ref.included,
      lowerBound = _ref.lowerBound,
      upperBound = _ref.upperBound,
      max = _ref.max,
      min = _ref.min,
      dotStyle = _ref.dotStyle,
      activeDotStyle = _ref.activeDotStyle;

var range = max - min;
  var elements = calcPoints(vertical, marks, dots, step, min, max).map(function (point) {
    var _classNames;

var offset = Math.abs(point - min) / range * 100 + '%';

var pointClassName = __WEBPACK_IMPORTED_MODULE_4_classnames___default()((_classNames = {}, __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-dot', true), __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_defineProperty___default()(_classNames, prefixCls + '-dot-active', isActived), _classNames));

return __WEBPACK_IMPORTED_MODULE_2_react___default.a.createElement('span', { className: pointClassName, style: style, key: point });
  });

return __WEBPACK_IMPORTED_MODULE_2_react___default.a.createElement(
    'div',
    { className: prefixCls + '-step' },
    elements
  );
};

Steps.propTypes = {
  prefixCls: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.string,
  activeDotStyle: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object,
  dotStyle: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object,
  min: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  max: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  upperBound: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  lowerBound: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  included: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.bool,
  dots: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.bool,
  step: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number,
  marks: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object,
  vertical: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.bool
};

/* harmony default export */ __webpack_exports__["a"] = (Steps);

/***/ }),
/* 1157 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__ = __webpack_require__(22);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_defineProperty__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties__ = __webpack_require__(54);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__ = __webpack_require__(20);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_prop_types__);

var classNames = __webpack_require__(9);

function noop() {}

var Switch = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_6_babel_runtime_helpers_inherits___default()(Switch, _Component);

function Switch(props) {
    __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_classCallCheck___default()(this, Switch);

var _this = __WEBPACK_IMPORTED_MODULE_5_babel_runtime_helpers_possibleConstructorReturn___default()(this, (Switch.__proto__ || Object.getPrototypeOf(Switch)).call(this, props));

_initialiseProps.call(_this);

__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_createClass___default()(Switch, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      var _props = this.props,
          autoFocus = _props.autoFocus,
          disabled = _props.disabled;

if (autoFocus && !disabled) {
        this.focus();
      }
    }
  }, {
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      if ('checked' in nextProps) {
        this.setState({
          checked: !!nextProps.checked
        });
      }
    }
  }, {
    key: 'setChecked',
    value: function setChecked(checked) {
      if (this.props.disabled) {
        return;
      }
      if (!('checked' in this.props)) {
        this.setState({
          checked: checked
        });
      }
      this.props.onChange(checked);
    }

// Handle auto focus when click switch in Chrome

}, {
    key: 'focus',
    value: function focus() {
      this.node.focus();
    }
  }, {
    key: 'blur',
    value: function blur() {
      this.node.blur();
    }
  }, {
    key: 'render',
    value: function render() {
      var _classNames;

var _props2 = this.props,
          className = _props2.className,
          prefixCls = _props2.prefixCls,
          disabled = _props2.disabled,
          loadingIcon = _props2.loadingIcon,
          checkedChildren = _props2.checkedChildren,
          unCheckedChildren = _props2.unCheckedChildren,
          restProps = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_objectWithoutProperties___default()(_props2, ['className', 'prefixCls', 'disabled', 'loadingIcon', 'checkedChildren', 'unCheckedChildren']);

return Switch;
}(__WEBPACK_IMPORTED_MODULE_7_react__["Component"]);

var _initialiseProps = function _initialiseProps() {
  var _this2 = this;

this.toggle = function () {
    var onClick = _this2.props.onClick;

var checked = !_this2.state.checked;
    _this2.setChecked(checked);
    onClick(checked);
  };

this.handleKeyDown = function (e) {
    if (e.keyCode === 37) {
      // Left
      _this2.setChecked(false);
    } else if (e.keyCode === 39) {
      // Right
      _this2.setChecked(true);
    }
  };

this.handleMouseUp = function (e) {
    if (_this2.node) {
      _this2.node.blur();
    }
    if (_this2.props.onMouseUp) {
      _this2.props.onMouseUp(e);
    }
  };

this.saveNode = function (node) {
    _this2.node = node;
  };
};

Switch.propTypes = {
  className: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.string,
  prefixCls: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.string,
  disabled: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  checkedChildren: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.any,
  unCheckedChildren: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.any,
  onChange: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.func,
  onMouseUp: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.func,
  onClick: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.func,
  tabIndex: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.number,
  checked: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  defaultChecked: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  autoFocus: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.bool,
  loadingIcon: __WEBPACK_IMPORTED_MODULE_8_prop_types___default.a.node
};

Switch.defaultProps = {
  prefixCls: 'rc-switch',
  checkedChildren: null,
  unCheckedChildren: null,
  className: '',
  defaultChecked: false,
  onChange: noop,
  onClick: noop
};

/* harmony default export */ __webpack_exports__["default"] = (Switch);

/***/ }),
/* 1158 */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(1157);

/***/ }),
/* 1159 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var Content = function (_React$Component) {
  __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_inherits___default()(Content, _React$Component);

function Content() {
    __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default()(this, Content);

return __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_possibleConstructorReturn___default()(this, _React$Component.apply(this, arguments));
  }

Content.prototype.componentDidUpdate = function componentDidUpdate() {
    var trigger = this.props.trigger;

if (trigger) {
      trigger.forcePopupAlign();
    }
  };

Content.prototype.render = function render() {
    var _props = this.props,
        overlay = _props.overlay,
        prefixCls = _props.prefixCls,
        id = _props.id;

return __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(
      'div',
      { className: prefixCls + '-inner', id: id, role: 'tooltip' },
      typeof overlay === 'function' ? overlay() : overlay
    );
  };

return Content;
}(__WEBPACK_IMPORTED_MODULE_3_react___default.a.Component);

Content.propTypes = {
  prefixCls: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string,
  overlay: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.node, __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func]).isRequired,
  id: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string,
  trigger: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.any
};
/* harmony default export */ __webpack_exports__["a"] = (Content);

/***/ }),
/* 1160 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_objectWithoutProperties__ = __webpack_require__(54);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_objectWithoutProperties___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_objectWithoutProperties__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rc_trigger__ = __webpack_require__(301);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__placements__ = __webpack_require__(477);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__Content__ = __webpack_require__(1159);

var Tooltip = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_4_babel_runtime_helpers_inherits___default()(Tooltip, _Component);

function Tooltip() {
    var _temp, _this, _ret;

__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_classCallCheck___default()(this, Tooltip);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

return _ret = (_temp = (_this = __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.getPopupElement = function () {
      var _this$props = _this.props,
          arrowContent = _this$props.arrowContent,
          overlay = _this$props.overlay,
          prefixCls = _this$props.prefixCls,
          id = _this$props.id;

return [__WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(
        'div',
        { className: prefixCls + '-arrow', key: 'arrow' },
        arrowContent
      ), __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_9__Content__["a" /* default */], {
        key: 'content',
        trigger: _this.trigger,
        prefixCls: prefixCls,
        id: id,
        overlay: overlay
      })];
    }, _this.saveTrigger = function (node) {
      _this.trigger = node;
    }, _temp), __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_possibleConstructorReturn___default()(_this, _ret);
  }

Tooltip.prototype.getPopupDomNode = function getPopupDomNode() {
    return this.trigger.getPopupDomNode();
  };

Tooltip.prototype.render = function render() {
    var _props = this.props,
        overlayClassName = _props.overlayClassName,
        trigger = _props.trigger,
        mouseEnterDelay = _props.mouseEnterDelay,
        mouseLeaveDelay = _props.mouseLeaveDelay,
        overlayStyle = _props.overlayStyle,
        prefixCls = _props.prefixCls,
        children = _props.children,
        onVisibleChange = _props.onVisibleChange,
        afterVisibleChange = _props.afterVisibleChange,
        transitionName = _props.transitionName,
        animation = _props.animation,
        placement = _props.placement,
        align = _props.align,
        destroyTooltipOnHide = _props.destroyTooltipOnHide,
        defaultVisible = _props.defaultVisible,
        getTooltipContainer = _props.getTooltipContainer,
        restProps = __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_objectWithoutProperties___default()(_props, ['overlayClassName', 'trigger', 'mouseEnterDelay', 'mouseLeaveDelay', 'overlayStyle', 'prefixCls', 'children', 'onVisibleChange', 'afterVisibleChange', 'transitionName', 'animation', 'placement', 'align', 'destroyTooltipOnHide', 'defaultVisible', 'getTooltipContainer']);

return Tooltip;
}(__WEBPACK_IMPORTED_MODULE_5_react__["Component"]);

Tooltip.propTypes = {
  trigger: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.any,
  children: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.any,
  defaultVisible: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  visible: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  placement: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  transitionName: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object]),
  animation: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.any,
  onVisibleChange: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  afterVisibleChange: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  overlay: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.node, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func]).isRequired,
  overlayStyle: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object,
  overlayClassName: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  prefixCls: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
  mouseEnterDelay: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  mouseLeaveDelay: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
  getTooltipContainer: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
  destroyTooltipOnHide: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
  align: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object,
  arrowContent: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.any,
  id: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string
};
Tooltip.defaultProps = {
  prefixCls: 'rc-tooltip',
  mouseEnterDelay: 0,
  destroyTooltipOnHide: false,
  mouseLeaveDelay: 0.1,
  align: {},
  placement: 'right',
  trigger: ['hover'],
  arrowContent: null
};

/* harmony default export */ __webpack_exports__["a"] = (Tooltip);

/***/ }),
/* 1161 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Tooltip__ = __webpack_require__(1160);

/* harmony default export */ __webpack_exports__["a"] = (__WEBPACK_IMPORTED_MODULE_0__Tooltip__["a" /* default */]);

/***/ }),
/* 1162 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__ = __webpack_require__(8);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__ = __webpack_require__(10);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__ = __webpack_require__(14);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__ = __webpack_require__(13);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react__ = __webpack_require__(0);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_react__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_prop_types__ = __webpack_require__(6);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_prop_types__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react_dom__ = __webpack_require__(7);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6_react_dom___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react_dom__);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7_rc_align__ = __webpack_require__(1125);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8_rc_animate__ = __webpack_require__(139);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__PopupInner__ = __webpack_require__(1163);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__LazyRenderBox__ = __webpack_require__(478);
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__utils__ = __webpack_require__(479);

var Popup = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_3_babel_runtime_helpers_inherits___default()(Popup, _Component);

function Popup(props) {
    __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_classCallCheck___default()(this, Popup);

var _this = __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_possibleConstructorReturn___default()(this, _Component.call(this, props));

_initialiseProps.call(_this);

_this.state = {
      // Used for stretch
      stretchChecked: false,
      targetWidth: undefined,
      targetHeight: undefined
    };

_this.savePopupRef = __WEBPACK_IMPORTED_MODULE_11__utils__["c" /* saveRef */].bind(_this, 'popupInstance');
    _this.saveAlignRef = __WEBPACK_IMPORTED_MODULE_11__utils__["c" /* saveRef */].bind(_this, 'alignInstance');
    return _this;
  }

Popup.prototype.componentDidMount = function componentDidMount() {
    this.rootNode = this.getPopupDomNode();
    this.setStretchSize();
  };

Popup.prototype.componentDidUpdate = function componentDidUpdate() {
    this.setStretchSize();
  };

// Record size if stretch needed

Popup.prototype.getPopupDomNode = function getPopupDomNode() {
    return __WEBPACK_IMPORTED_MODULE_6_react_dom___default.a.findDOMNode(this.popupInstance);
  };

// `target` on `rc-align` can accept as a function to get the bind element or a point.
  // ref: https://www.npmjs.com/package/rc-align

Popup.prototype.getMaskTransitionName = function getMaskTransitionName() {
    var props = this.props;
    var transitionName = props.maskTransitionName;
    var animation = props.maskAnimation;
    if (!transitionName && animation) {
      transitionName = props.prefixCls + '-' + animation;
    }
    return transitionName;
  };

Popup.prototype.getTransitionName = function getTransitionName() {
    var props = this.props;
    var transitionName = props.transitionName;
    if (!transitionName && props.animation) {
      transitionName = props.prefixCls + '-' + props.animation;
    }
    return transitionName;
  };

Popup.prototype.getClassName = function getClassName(currentAlignClassName) {
    return this.props.prefixCls + ' ' + this.props.className + ' ' + currentAlignClassName;
  };

Popup.prototype.getPopupElement = function getPopupElement() {
    var _this2 = this;

var savePopupRef = this.savePopupRef;
    var _state = this.state,
        stretchChecked = _state.stretchChecked,
        targetHeight = _state.targetHeight,
        targetWidth = _state.targetWidth;
    var _props = this.props,
        align = _props.align,
        visible = _props.visible,
        prefixCls = _props.prefixCls,
        style = _props.style,
        getClassNameFromAlign = _props.getClassNameFromAlign,
        destroyPopupOnHide = _props.destroyPopupOnHide,
        stretch = _props.stretch,
        children = _props.children,
        onMouseEnter = _props.onMouseEnter,
        onMouseLeave = _props.onMouseLeave,
        onMouseDown = _props.onMouseDown,
        onTouchStart = _props.onTouchStart;

var className = this.getClassName(this.currentAlignClassName || getClassNameFromAlign(align));
    var hiddenClassName = prefixCls + '-hidden';

if (!visible) {
      this.currentAlignClassName = null;
    }

// Delay force align to makes ui smooth
      if (!stretchChecked) {
        sizeStyle.visibility = 'hidden';
        setTimeout(function () {
          if (_this2.alignInstance) {
            _this2.alignInstance.forceAlign();
          }
        }, 0);
      }
    }

var newStyle = __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({}, sizeStyle, style, this.getZIndexStyle());

var popupInnerProps = {
      className: className,
      prefixCls: prefixCls,
      ref: savePopupRef,
      onMouseEnter: onMouseEnter,
      onMouseLeave: onMouseLeave,
      onMouseDown: onMouseDown,
      onTouchStart: onTouchStart,
      style: newStyle
    };
    if (destroyPopupOnHide) {
      return __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
        __WEBPACK_IMPORTED_MODULE_8_rc_animate__["a" /* default */],
        {
          component: '',
          exclusive: true,
          transitionAppear: true,
          transitionName: this.getTransitionName()
        },
        visible ? __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
          __WEBPACK_IMPORTED_MODULE_7_rc_align__["a" /* default */],
          {
            target: this.getAlignTarget(),
            key: 'popup',
            ref: this.saveAlignRef,
            monitorWindowResize: true,
            align: align,
            onAlign: this.onAlign
          },
          __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
            __WEBPACK_IMPORTED_MODULE_9__PopupInner__["a" /* default */],
            __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({
              visible: true
            }, popupInnerProps),
            children
          )
        ) : null
      );
    }

return __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
      __WEBPACK_IMPORTED_MODULE_8_rc_animate__["a" /* default */],
      {
        component: '',
        exclusive: true,
        transitionAppear: true,
        transitionName: this.getTransitionName(),
        showProp: 'xVisible'
      },
      __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
        __WEBPACK_IMPORTED_MODULE_7_rc_align__["a" /* default */],
        {
          target: this.getAlignTarget(),
          key: 'popup',
          ref: this.saveAlignRef,
          monitorWindowResize: true,
          xVisible: visible,
          childrenProps: { visible: 'xVisible' },
          disabled: !visible,
          align: align,
          onAlign: this.onAlign
        },
        __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
          __WEBPACK_IMPORTED_MODULE_9__PopupInner__["a" /* default */],
          __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_extends___default()({
            hiddenClassName: hiddenClassName
          }, popupInnerProps),
          children
        )
      )
    );
  };

Popup.prototype.getZIndexStyle = function getZIndexStyle() {
    var style = {};
    var props = this.props;
    if (props.zIndex !== undefined) {
      style.zIndex = props.zIndex;
    }
    return style;
  };

Popup.prototype.getMaskElement = function getMaskElement() {
    var props = this.props;
    var maskElement = void 0;
    if (props.mask) {
      var maskTransition = this.getMaskTransitionName();
      maskElement = __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_10__LazyRenderBox__["a" /* default */], {
        style: this.getZIndexStyle(),
        key: 'mask',
        className: props.prefixCls + '-mask',
        hiddenClassName: props.prefixCls + '-mask-hidden',
        visible: props.visible
      });
      if (maskTransition) {
        maskElement = __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
          __WEBPACK_IMPORTED_MODULE_8_rc_animate__["a" /* default */],
          {
            key: 'mask',
            showProp: 'visible',
            transitionAppear: true,
            component: '',
            transitionName: maskTransition
          },
          maskElement
        );
      }
    }
    return maskElement;
  };

Popup.prototype.render = function render() {
    return __WEBPACK_IMPORTED_MODULE_4_react___default.a.createElement(
      'div',
      null,
      this.getMaskElement(),
      this.getPopupElement()
    );
  };

return Popup;
}(__WEBPACK_IMPORTED_MODULE_4_react__["Component"]);

Popup.propTypes = {
  visible: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  style: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.object,
  getClassNameFromAlign: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  onAlign: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  getRootDomNode: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  align: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.any,
  destroyPopupOnHide: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.bool,
  className: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  prefixCls: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  onMouseEnter: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  onMouseLeave: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  onMouseDown: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  onTouchStart: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.func,
  stretch: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.string,
  children: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.node,
  point: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.shape({
    pageX: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number,
    pageY: __WEBPACK_IMPORTED_MODULE_5_prop_types___default.a.number
  })
};

var _initialiseProps = function _initialiseProps() {
  var _this3 = this;

this.onAlign = function (popupDomNode, align) {
    var props = _this3.props;
    var currentAlignClassName = props.getClassNameFromAlign(align);
    // FIX: https://github.com/react-component/trigger/issues/56
    // FIX: https://github.com/react-component/tooltip/issues/79
    if (_this3.currentAlignClassName !== currentAlignClassName) {
      _this3.currentAlignClassName = currentAlignClassName;
      popupDomNode.className = _this3.getClassName(currentAlignClassName);
    }
    props.onAlign(popupDomNode, align);
  };

this.setStretchSize = function () {
    var _props2 = _this3.props,
        stretch = _props2.stretch,
        getRootDomNode = _props2.getRootDomNode,
        visible = _props2.visible;
    var _state2 = _this3.state,
        stretchChecked = _state2.stretchChecked,
        targetHeight = _state2.targetHeight,
        targetWidth = _state2.targetWidth;

if (!stretch || !visible) {
      if (stretchChecked) {
        _this3.setState({ stretchChecked: false });
      }
      return;
    }

var $ele = getRootDomNode();
    if (!$ele) return;

var height = $ele.offsetHeight;
    var width = $ele.offsetWidth;

if (targetHeight !== height || targetWidth !== width || !stretchChecked) {
      _this3.setState({
        stretchChecked: true,
        targetHeight: height,
        targetWidth: width
      });
    }
  };

this.getTargetElement = function () {
    return _this3.props.getRootDomNode();
  };

this.getAlignTarget = function () {
    var point = _this3.props.point;

if (point) {
      return point;
    }
    return _this3.getTargetElement;
  };
};

/* harmony default export */ __webpack_exports__["a"] = (Popup);

/***/ }),
/* 1163 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var PopupInner = function (_Component) {
  __WEBPACK_IMPORTED_MODULE_2_babel_runtime_helpers_inherits___default()(PopupInner, _Component);

function PopupInner() {
    __WEBPACK_IMPORTED_MODULE_0_babel_runtime_helpers_classCallCheck___default()(this, PopupInner);

return __WEBPACK_IMPORTED_MODULE_1_babel_runtime_helpers_possibleConstructorReturn___default()(this, _Component.apply(this, arguments));
  }

PopupInner.prototype.render = function render() {
    var props = this.props;
    var className = props.className;
    if (!props.visible) {
      className += ' ' + props.hiddenClassName;
    }
    return __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(
      'div',
      {
        className: className,
        onMouseEnter: props.onMouseEnter,
        onMouseLeave: props.onMouseLeave,
        onMouseDown: props.onMouseDown,
        onTouchStart: props.onTouchStart,
        style: props.style
      },
      __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(
        __WEBPACK_IMPORTED_MODULE_5__LazyRenderBox__["a" /* default */],
        { className: props.prefixCls + '-content', visible: props.visible },
        props.children
      )
    );
  };

return PopupInner;
}(__WEBPACK_IMPORTED_MODULE_3_react__["Component"]);

PopupInner.propTypes = {
  hiddenClassName: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string,
  className: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string,
  prefixCls: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string,
  onMouseEnter: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func,
  onMouseLeave: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func,
  onMouseDown: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func,
  onTouchStart: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func,
  children: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.any
};

/* harmony default export */ __webpack_exports__["a"] = (PopupInner);

/***/ }),
/* 1164 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = createChainedFunction;
/**
 * Safe chained function
 *
 * Will only create a new function if needed,
 * otherwise will pass back existing functions or null.
 *
 * @returns {function|null}
 */
function createChainedFunction() {
  var args = [].slice.call(arguments, 0);

if (args.length === 1) {
    return args[0];
  }

return function chainedFunction() {
    for (var i = 0; i < args.length; i++) {
      if (args[i] && args[i].apply) {
        args[i].apply(this, arguments);
      }
    }
  };
}

/***/ }),
/* 1165 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (immutable) */ __webpack_exports__["a"] = getScrollBarSize;
var cached;
function getScrollBarSize(fresh) {
  if (typeof document === 'undefined') {
    return 0;
  }

if (fresh || cached === undefined) {
    var inner = document.createElement('div');
    inner.style.width = '100%';
    inner.style.height = '200px';
    var outer = document.createElement('div');
    var outerStyle = outer.style;
    outerStyle.position = 'absolute';
    outerStyle.top = 0;
    outerStyle.left = 0;
    outerStyle.pointerEvents = 'none';
    outerStyle.visibility = 'hidden';
    outerStyle.width = '200px';
    outerStyle.height = '150px';
    outerStyle.overflow = 'hidden';
    outer.appendChild(inner);
    document.body.appendChild(outer);
    var widthContained = inner.offsetWidth;
    outer.style.overflow = 'scroll';
    var widthScroll = inner.offsetWidth;

if (widthContained === widthScroll) {
      widthScroll = outer.clientWidth;
    }

document.body.removeChild(outer);
    cached = widthContained - widthScroll;
  }

return cached;
}

/***/ }),
/* 1166 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

var unsafeLifecyclesPolyfill = function unsafeLifecyclesPolyfill(Component) {
  var prototype = Component.prototype;

if (!prototype || !prototype.isReactComponent) {
    throw new Error('Can only polyfill class components');
  } // only handle componentWillReceiveProps

if (typeof prototype.componentWillReceiveProps !== 'function') {
    return Component;
  } // In React 16.9, React.Profiler was introduced together with UNSAFE_componentWillReceiveProps
  // https://reactjs.org/blog/2019/08/08/react-v16.9.0.html#performance-measurements-with-reactprofiler

if (!__WEBPACK_IMPORTED_MODULE_0_react___default.a.Profiler) {
    return Component;
  } // Here polyfill get started

prototype.UNSAFE_componentWillReceiveProps = prototype.componentWillReceiveProps;
  delete prototype.componentWillReceiveProps;
  return Component;
};

/* harmony default export */ __webpack_exports__["a"] = (unsafeLifecyclesPolyfill);

/***/ }),
/* 1167 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
  return typeof obj;
} : function(obj) {
  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};

/***/ }),
/* 1168 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.AlphaPicker = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

var _AlphaPointer = __webpack_require__(1169);

var _AlphaPointer2 = _interopRequireDefault(_AlphaPointer);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var AlphaPicker = exports.AlphaPicker = function AlphaPicker(_ref) {
  var rgb = _ref.rgb,
      hsl = _ref.hsl,
      width = _ref.width,
      height = _ref.height,
      onChange = _ref.onChange,
      direction = _ref.direction,
      style = _ref.style,
      renderers = _ref.renderers,
      pointer = _ref.pointer,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        position: 'relative',
        width: width,
        height: height
      },
      alpha: {
        radius: '2px',
        style: style
      }
    }
  });

return _react2.default.createElement(
    'div',
    { style: styles.picker, className: 'alpha-picker ' + className },
    _react2.default.createElement(_common.Alpha, _extends({}, styles.alpha, {
      rgb: rgb,
      hsl: hsl,
      pointer: pointer,
      renderers: renderers,
      onChange: onChange,
      direction: direction
    }))
  );
};

AlphaPicker.defaultProps = {
  width: '316px',
  height: '16px',
  direction: 'horizontal',
  pointer: _AlphaPointer2.default
};

exports.default = (0, _common.ColorWrap)(AlphaPicker);

/***/ }),
/* 1169 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.AlphaPointer = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var AlphaPointer = exports.AlphaPointer = function AlphaPointer(_ref) {
  var direction = _ref.direction;

var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        width: '18px',
        height: '18px',
        borderRadius: '50%',
        transform: 'translate(-9px, -1px)',
        backgroundColor: 'rgb(248, 248, 248)',
        boxShadow: '0 1px 4px 0 rgba(0, 0, 0, 0.37)'
      }
    },
    'vertical': {
      picker: {
        transform: 'translate(-3px, -9px)'
      }
    }
  }, { vertical: direction === 'vertical' });

return _react2.default.createElement('div', { style: styles.picker });
};

exports.default = AlphaPointer;

/***/ }),
/* 1170 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Block = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

var _BlockSwatches = __webpack_require__(1171);

var _BlockSwatches2 = _interopRequireDefault(_BlockSwatches);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Block = exports.Block = function Block(_ref) {
  var onChange = _ref.onChange,
      onSwatchHover = _ref.onSwatchHover,
      hex = _ref.hex,
      colors = _ref.colors,
      width = _ref.width,
      triangle = _ref.triangle,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var transparent = hex === 'transparent';
  var handleChange = function handleChange(hexCode, e) {
    _color2.default.isValidHex(hexCode) && onChange({
      hex: hexCode,
      source: 'hex'
    }, e);
  };

var styles = (0, _reactcss2.default)({
    'default': {
      card: {
        width: width,
        background: '#fff',
        boxShadow: '0 1px rgba(0,0,0,.1)',
        borderRadius: '6px',
        position: 'relative'
      },
      head: {
        height: '110px',
        background: hex,
        borderRadius: '6px 6px 0 0',
        display: 'flex',
        alignItems: 'center',
        justifyContent: 'center',
        position: 'relative'
      },
      body: {
        padding: '10px'
      },
      label: {
        fontSize: '18px',
        color: _color2.default.getContrastingColor(hex),
        position: 'relative'
      },
      triangle: {
        width: '0px',
        height: '0px',
        borderStyle: 'solid',
        borderWidth: '0 10px 10px 10px',
        borderColor: 'transparent transparent ' + hex + ' transparent',
        position: 'absolute',
        top: '-10px',
        left: '50%',
        marginLeft: '-10px'
      },
      input: {
        width: '100%',
        fontSize: '12px',
        color: '#666',
        border: '0px',
        outline: 'none',
        height: '22px',
        boxShadow: 'inset 0 0 0 1px #ddd',
        borderRadius: '4px',
        padding: '0 7px',
        boxSizing: 'border-box'
      }
    },
    'hide-triangle': {
      triangle: {
        display: 'none'
      }
    }
  }, { 'hide-triangle': triangle === 'hide' });

return _react2.default.createElement(
    'div',
    { style: styles.card, className: 'block-picker ' + className },
    _react2.default.createElement('div', { style: styles.triangle }),
    _react2.default.createElement(
      'div',
      { style: styles.head },
      transparent && _react2.default.createElement(_common.Checkboard, { borderRadius: '6px 6px 0 0' }),
      _react2.default.createElement(
        'div',
        { style: styles.label },
        hex
      )
    ),
    _react2.default.createElement(
      'div',
      { style: styles.body },
      _react2.default.createElement(_BlockSwatches2.default, { colors: colors, onClick: handleChange, onSwatchHover: onSwatchHover }),
      _react2.default.createElement(_common.EditableInput, {
        style: { input: styles.input },
        value: hex,
        onChange: handleChange
      })
    )
  );
};

Block.propTypes = {
  width: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
  colors: _propTypes2.default.arrayOf(_propTypes2.default.string),
  triangle: _propTypes2.default.oneOf(['top', 'hide'])
};

Block.defaultProps = {
  width: 170,
  colors: ['#D9E3F0', '#F47373', '#697689', '#37D67A', '#2CCCE4', '#555555', '#dce775', '#ff8a65', '#ba68c8'],
  triangle: 'top'
};

exports.default = (0, _common.ColorWrap)(Block);

/***/ }),
/* 1171 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BlockSwatches = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _map = __webpack_require__(74);

var _map2 = _interopRequireDefault(_map);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var BlockSwatches = exports.BlockSwatches = function BlockSwatches(_ref) {
  var colors = _ref.colors,
      onClick = _ref.onClick,
      onSwatchHover = _ref.onSwatchHover;

var styles = (0, _reactcss2.default)({
    'default': {
      swatches: {
        marginRight: '-10px'
      },
      swatch: {
        width: '22px',
        height: '22px',
        float: 'left',
        marginRight: '10px',
        marginBottom: '10px',
        borderRadius: '4px'
      },
      clear: {
        clear: 'both'
      }
    }
  });

return _react2.default.createElement(
    'div',
    { style: styles.swatches },
    (0, _map2.default)(colors, function (c) {
      return _react2.default.createElement(_common.Swatch, {
        key: c,
        color: c,
        style: styles.swatch,
        onClick: onClick,
        onHover: onSwatchHover,
        focusStyle: {
          boxShadow: '0 0 4px ' + c
        }
      });
    }),
    _react2.default.createElement('div', { style: styles.clear })
  );
};

exports.default = BlockSwatches;

/***/ }),
/* 1172 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Chrome = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

var _ChromeFields = __webpack_require__(1173);

var _ChromeFields2 = _interopRequireDefault(_ChromeFields);

var _ChromePointer = __webpack_require__(1174);

var _ChromePointer2 = _interopRequireDefault(_ChromePointer);

var _ChromePointerCircle = __webpack_require__(1175);

var _ChromePointerCircle2 = _interopRequireDefault(_ChromePointerCircle);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Chrome = exports.Chrome = function Chrome(_ref) {
  var onChange = _ref.onChange,
      disableAlpha = _ref.disableAlpha,
      rgb = _ref.rgb,
      hsl = _ref.hsl,
      hsv = _ref.hsv,
      hex = _ref.hex,
      renderers = _ref.renderers,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        background: '#fff',
        borderRadius: '2px',
        boxShadow: '0 0 2px rgba(0,0,0,.3), 0 4px 8px rgba(0,0,0,.3)',
        boxSizing: 'initial',
        width: '225px',
        fontFamily: 'Menlo'
      },
      saturation: {
        width: '100%',
        paddingBottom: '55%',
        position: 'relative',
        borderRadius: '2px 2px 0 0',
        overflow: 'hidden'
      },
      Saturation: {
        radius: '2px 2px 0 0'
      },
      body: {
        padding: '16px 16px 12px'
      },
      controls: {
        display: 'flex'
      },
      color: {
        width: '32px'
      },
      swatch: {
        marginTop: '6px',
        width: '16px',
        height: '16px',
        borderRadius: '8px',
        position: 'relative',
        overflow: 'hidden'
      },
      active: {
        absolute: '0px 0px 0px 0px',
        borderRadius: '8px',
        boxShadow: 'inset 0 0 0 1px rgba(0,0,0,.1)',
        background: 'rgba(' + rgb.r + ', ' + rgb.g + ', ' + rgb.b + ', ' + rgb.a + ')',
        zIndex: '2'
      },
      toggles: {
        flex: '1'
      },
      hue: {
        height: '10px',
        position: 'relative',
        marginBottom: '8px'
      },
      Hue: {
        radius: '2px'
      },
      alpha: {
        height: '10px',
        position: 'relative'
      },
      Alpha: {
        radius: '2px'
      }
    },
    'disableAlpha': {
      color: {
        width: '22px'
      },
      alpha: {
        display: 'none'
      },
      hue: {
        marginBottom: '0px'
      },
      swatch: {
        width: '10px',
        height: '10px',
        marginTop: '0px'
      }
    }
  }, { disableAlpha: disableAlpha });

return _react2.default.createElement(
    'div',
    { style: styles.picker, className: 'chrome-picker ' + className },
    _react2.default.createElement(
      'div',
      { style: styles.saturation },
      _react2.default.createElement(_common.Saturation, {
        style: styles.Saturation,
        hsl: hsl,
        hsv: hsv,
        pointer: _ChromePointerCircle2.default,
        onChange: onChange
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.body },
      _react2.default.createElement(
        'div',
        { style: styles.controls, className: 'flexbox-fix' },
        _react2.default.createElement(
          'div',
          { style: styles.color },
          _react2.default.createElement(
            'div',
            { style: styles.swatch },
            _react2.default.createElement('div', { style: styles.active }),
            _react2.default.createElement(_common.Checkboard, { renderers: renderers })
          )
        ),
        _react2.default.createElement(
          'div',
          { style: styles.toggles },
          _react2.default.createElement(
            'div',
            { style: styles.hue },
            _react2.default.createElement(_common.Hue, {
              style: styles.Hue,
              hsl: hsl,
              pointer: _ChromePointer2.default,
              onChange: onChange
            })
          ),
          _react2.default.createElement(
            'div',
            { style: styles.alpha },
            _react2.default.createElement(_common.Alpha, {
              style: styles.Alpha,
              rgb: rgb,
              hsl: hsl,
              pointer: _ChromePointer2.default,
              renderers: renderers,
              onChange: onChange
            })
          )
        )
      ),
      _react2.default.createElement(_ChromeFields2.default, {
        rgb: rgb,
        hsl: hsl,
        hex: hex,
        onChange: onChange,
        disableAlpha: disableAlpha
      })
    )
  );
};

Chrome.propTypes = {
  disableAlpha: _propTypes2.default.bool
};

Chrome.defaultProps = {
  disableAlpha: false
};

exports.default = (0, _common.ColorWrap)(Chrome);

/***/ }),
/* 1173 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ChromeFields = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var ChromeFields = exports.ChromeFields = function (_React$Component) {
  _inherits(ChromeFields, _React$Component);

function ChromeFields() {
    var _ref;

var _temp, _this, _ret;

_classCallCheck(this, ChromeFields);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = ChromeFields.__proto__ || Object.getPrototypeOf(ChromeFields)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
      view: ''
    }, _this.toggleViews = function () {
      if (_this.state.view === 'hex') {
        _this.setState({ view: 'rgb' });
      } else if (_this.state.view === 'rgb') {
        _this.setState({ view: 'hsl' });
      } else if (_this.state.view === 'hsl') {
        if (_this.props.hsl.a === 1) {
          _this.setState({ view: 'hex' });
        } else {
          _this.setState({ view: 'rgb' });
        }
      }
    }, _this.handleChange = function (data, e) {
      if (data.hex) {
        _color2.default.isValidHex(data.hex) && _this.props.onChange({
          hex: data.hex,
          source: 'hex'
        }, e);
      } else if (data.r || data.g || data.b) {
        _this.props.onChange({
          r: data.r || _this.props.rgb.r,
          g: data.g || _this.props.rgb.g,
          b: data.b || _this.props.rgb.b,
          source: 'rgb'
        }, e);
      } else if (data.a) {
        if (data.a < 0) {
          data.a = 0;
        } else if (data.a > 1) {
          data.a = 1;
        }

_this.props.onChange({
          h: _this.props.hsl.h,
          s: _this.props.hsl.s,
          l: _this.props.hsl.l,
          a: Math.round(data.a * 100) / 100,
          source: 'rgb'
        }, e);
      } else if (data.h || data.s || data.l) {
        _this.props.onChange({
          h: data.h || _this.props.hsl.h,
          s: Number(data.s && data.s || _this.props.hsl.s),
          l: Number(data.l && data.l || _this.props.hsl.l),
          source: 'hsl'
        }, e);
      }
    }, _this.showHighlight = function (e) {
      e.target.style.background = '#eee';
    }, _this.hideHighlight = function (e) {
      e.target.style.background = 'transparent';
    }, _temp), _possibleConstructorReturn(_this, _ret);
  }

_createClass(ChromeFields, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      if (this.props.hsl.a === 1 && this.state.view !== 'hex') {
        this.setState({ view: 'hex' });
      } else if (this.state.view !== 'rgb' && this.state.view !== 'hsl') {
        this.setState({ view: 'rgb' });
      }
    }
  }, {
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      if (nextProps.hsl.a !== 1 && this.state.view === 'hex') {
        this.setState({ view: 'rgb' });
      }
    }
  }, {
    key: 'render',
    value: function render() {
      var _this2 = this;

var styles = (0, _reactcss2.default)({
        'default': {
          wrap: {
            paddingTop: '16px',
            display: 'flex'
          },
          fields: {
            flex: '1',
            display: 'flex',
            marginLeft: '-6px'
          },
          field: {
            paddingLeft: '6px',
            width: '100%'
          },
          alpha: {
            paddingLeft: '6px',
            width: '100%'
          },
          toggle: {
            width: '32px',
            textAlign: 'right',
            position: 'relative'
          },
          icon: {
            marginRight: '-4px',
            marginTop: '12px',
            cursor: 'pointer',
            position: 'relative'
          },
          iconHighlight: {
            position: 'absolute',
            width: '24px',
            height: '28px',
            background: '#eee',
            borderRadius: '4px',
            top: '10px',
            left: '12px',
            display: 'none'
          },
          input: {
            fontSize: '11px',
            color: '#333',
            width: '100%',
            borderRadius: '2px',
            border: 'none',
            boxShadow: 'inset 0 0 0 1px #dadada',
            height: '21px',
            textAlign: 'center'
          },
          label: {
            textTransform: 'uppercase',
            fontSize: '11px',
            lineHeight: '11px',
            color: '#969696',
            textAlign: 'center',
            display: 'block',
            marginTop: '12px'
          },
          svg: {
            width: '24px',
            height: '24px',
            border: '1px transparent solid',
            borderRadius: '5px'
          }
        },
        'disableAlpha': {
          alpha: {
            display: 'none'
          }
        }
      }, this.props, this.state);

return _react2.default.createElement(
        'div',
        { style: styles.wrap, className: 'flexbox-fix' },
        fields,
        _react2.default.createElement(
          'div',
          { style: styles.toggle },
          _react2.default.createElement(
            'div',
            { style: styles.icon, onClick: this.toggleViews, ref: function ref(icon) {
                return _this2.icon = icon;
              } },
            _react2.default.createElement(
              'svg',
              {
                style: styles.svg,
                viewBox: '0 0 24 24',
                onMouseOver: this.showHighlight,
                onMouseEnter: this.showHighlight,
                onMouseOut: this.hideHighlight
              },
              _react2.default.createElement('path', {
                ref: function ref(iconUp) {
                  return _this2.iconUp = iconUp;
                },
                fill: '#333',
                d: 'M12,5.83L15.17,9L16.58,7.59L12,3L7.41,7.59L8.83,9L12,5.83Z'
              }),
              _react2.default.createElement('path', {
                ref: function ref(iconDown) {
                  return _this2.iconDown = iconDown;
                },
                fill: '#333',
                d: 'M12,18.17L8.83,15L7.42,16.41L12,21L16.59,16.41L15.17,15Z'
              })
            )
          )
        )
      );
    }
  }]);

return ChromeFields;
}(_react2.default.Component);

exports.default = ChromeFields;

/***/ }),
/* 1174 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ChromePointer = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ChromePointer = exports.ChromePointer = function ChromePointer() {
  var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        width: '12px',
        height: '12px',
        borderRadius: '6px',
        transform: 'translate(-6px, -1px)',
        backgroundColor: 'rgb(248, 248, 248)',
        boxShadow: '0 1px 4px 0 rgba(0, 0, 0, 0.37)'
      }
    }
  });

return _react2.default.createElement('div', { style: styles.picker });
};

exports.default = ChromePointer;

/***/ }),
/* 1175 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ChromePointerCircle = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ChromePointerCircle = exports.ChromePointerCircle = function ChromePointerCircle() {
  var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        width: '12px',
        height: '12px',
        borderRadius: '6px',
        boxShadow: 'inset 0 0 0 1px #fff',
        transform: 'translate(-6px, -6px)'
      }
    }
  });

return _react2.default.createElement('div', { style: styles.picker });
};

exports.default = ChromePointerCircle;

/***/ }),
/* 1176 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Circle = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _map = __webpack_require__(74);

var _map2 = _interopRequireDefault(_map);

var _materialColors = __webpack_require__(458);

var material = _interopRequireWildcard(_materialColors);

var _common = __webpack_require__(25);

var _CircleSwatch = __webpack_require__(1177);

var _CircleSwatch2 = _interopRequireDefault(_CircleSwatch);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Circle = exports.Circle = function Circle(_ref) {
  var width = _ref.width,
      onChange = _ref.onChange,
      onSwatchHover = _ref.onSwatchHover,
      colors = _ref.colors,
      hex = _ref.hex,
      circleSize = _ref.circleSize,
      circleSpacing = _ref.circleSpacing,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      card: {
        width: width,
        display: 'flex',
        flexWrap: 'wrap',
        marginRight: -circleSpacing,
        marginBottom: -circleSpacing
      }
    }
  });

var handleChange = function handleChange(hexCode, e) {
    return onChange({ hex: hexCode, source: 'hex' }, e);
  };

return _react2.default.createElement(
    'div',
    { style: styles.card, className: 'circle-picker ' + className },
    (0, _map2.default)(colors, function (c) {
      return _react2.default.createElement(_CircleSwatch2.default, {
        key: c,
        color: c,
        onClick: handleChange,
        onSwatchHover: onSwatchHover,
        active: hex === c.toLowerCase(),
        circleSize: circleSize,
        circleSpacing: circleSpacing
      });
    })
  );
};

Circle.propTypes = {
  width: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
  circleSize: _propTypes2.default.number,
  circleSpacing: _propTypes2.default.number
};

Circle.defaultProps = {
  width: 252,
  circleSize: 28,
  circleSpacing: 14,
  colors: [material.red['500'], material.pink['500'], material.purple['500'], material.deepPurple['500'], material.indigo['500'], material.blue['500'], material.lightBlue['500'], material.cyan['500'], material.teal['500'], material.green['500'], material.lightGreen['500'], material.lime['500'], material.yellow['500'], material.amber['500'], material.orange['500'], material.deepOrange['500'], material.brown['500'], material.blueGrey['500']]
};

exports.default = (0, _common.ColorWrap)(Circle);

/***/ }),
/* 1177 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CircleSwatch = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var CircleSwatch = exports.CircleSwatch = function CircleSwatch(_ref) {
  var color = _ref.color,
      onClick = _ref.onClick,
      onSwatchHover = _ref.onSwatchHover,
      hover = _ref.hover,
      active = _ref.active,
      circleSize = _ref.circleSize,
      circleSpacing = _ref.circleSpacing;

var styles = (0, _reactcss2.default)({
    'default': {
      swatch: {
        width: circleSize,
        height: circleSize,
        marginRight: circleSpacing,
        marginBottom: circleSpacing,
        transform: 'scale(1)',
        transition: '100ms transform ease'
      },
      Swatch: {
        borderRadius: '50%',
        background: 'transparent',
        boxShadow: 'inset 0 0 0 ' + circleSize / 2 + 'px ' + color,
        transition: '100ms box-shadow ease'
      }
    },
    'hover': {
      swatch: {
        transform: 'scale(1.2)'
      }
    },
    'active': {
      Swatch: {
        boxShadow: 'inset 0 0 0 3px ' + color
      }
    }
  }, { hover: hover, active: active });

return _react2.default.createElement(
    'div',
    { style: styles.swatch },
    _react2.default.createElement(_common.Swatch, {
      style: styles.Swatch,
      color: color,
      onClick: onClick,
      onHover: onSwatchHover,
      focusStyle: { boxShadow: styles.Swatch.boxShadow + ', 0 0 5px ' + color }
    })
  );
};

CircleSwatch.defaultProps = {
  circleSize: 28,
  circleSpacing: 14
};

exports.default = (0, _reactcss.handleHover)(CircleSwatch);

/***/ }),
/* 1178 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Alpha = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _alpha = __webpack_require__(1209);

var alpha = _interopRequireWildcard(_alpha);

var _Checkboard = __webpack_require__(483);

var _Checkboard2 = _interopRequireDefault(_Checkboard);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Alpha = exports.Alpha = function (_ref) {
  _inherits(Alpha, _ref);

function Alpha() {
    var _ref2;

var _temp, _this, _ret;

_classCallCheck(this, Alpha);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref2 = Alpha.__proto__ || Object.getPrototypeOf(Alpha)).call.apply(_ref2, [this].concat(args))), _this), _this.handleChange = function (e, skip) {
      var change = alpha.calculateChange(e, skip, _this.props, _this.container);
      change && _this.props.onChange && _this.props.onChange(change, e);
    }, _this.handleMouseDown = function (e) {
      _this.handleChange(e, true);
      window.addEventListener('mousemove', _this.handleChange);
      window.addEventListener('mouseup', _this.handleMouseUp);
    }, _this.handleMouseUp = function () {
      _this.unbindEventListeners();
    }, _this.unbindEventListeners = function () {
      window.removeEventListener('mousemove', _this.handleChange);
      window.removeEventListener('mouseup', _this.handleMouseUp);
    }, _temp), _possibleConstructorReturn(_this, _ret);
  }

_createClass(Alpha, [{
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this.unbindEventListeners();
    }
  }, {
    key: 'render',
    value: function render() {
      var _this2 = this;

var rgb = this.props.rgb;
      var styles = (0, _reactcss2.default)({
        'default': {
          alpha: {
            absolute: '0px 0px 0px 0px',
            borderRadius: this.props.radius
          },
          checkboard: {
            absolute: '0px 0px 0px 0px',
            overflow: 'hidden',
            borderRadius: this.props.radius
          },
          gradient: {
            absolute: '0px 0px 0px 0px',
            background: 'linear-gradient(to right, rgba(' + rgb.r + ',' + rgb.g + ',' + rgb.b + ', 0) 0%,\n           rgba(' + rgb.r + ',' + rgb.g + ',' + rgb.b + ', 1) 100%)',
            boxShadow: this.props.shadow,
            borderRadius: this.props.radius
          },
          container: {
            position: 'relative',
            height: '100%',
            margin: '0 3px'
          },
          pointer: {
            position: 'absolute',
            left: rgb.a * 100 + '%'
          },
          slider: {
            width: '4px',
            borderRadius: '1px',
            height: '8px',
            boxShadow: '0 0 2px rgba(0, 0, 0, .6)',
            background: '#fff',
            marginTop: '1px',
            transform: 'translateX(-2px)'
          }
        },
        'vertical': {
          gradient: {
            background: 'linear-gradient(to bottom, rgba(' + rgb.r + ',' + rgb.g + ',' + rgb.b + ', 0) 0%,\n           rgba(' + rgb.r + ',' + rgb.g + ',' + rgb.b + ', 1) 100%)'
          },
          pointer: {
            left: 0,
            top: rgb.a * 100 + '%'
          }
        },
        'overwrite': _extends({}, this.props.style)
      }, {
        vertical: this.props.direction === 'vertical',
        overwrite: true
      });

return _react2.default.createElement(
        'div',
        { style: styles.alpha },
        _react2.default.createElement(
          'div',
          { style: styles.checkboard },
          _react2.default.createElement(_Checkboard2.default, { renderers: this.props.renderers })
        ),
        _react2.default.createElement('div', { style: styles.gradient }),
        _react2.default.createElement(
          'div',
          {
            style: styles.container,
            ref: function ref(container) {
              return _this2.container = container;
            },
            onMouseDown: this.handleMouseDown,
            onTouchMove: this.handleChange,
            onTouchStart: this.handleChange
          },
          _react2.default.createElement(
            'div',
            { style: styles.pointer },
            this.props.pointer ? _react2.default.createElement(this.props.pointer, this.props) : _react2.default.createElement('div', { style: styles.slider })
          )
        )
      );
    }
  }]);

return Alpha;
}(_react.PureComponent || _react.Component);

exports.default = Alpha;

/***/ }),
/* 1179 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.EditableInput = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var EditableInput = exports.EditableInput = function (_ref) {
  _inherits(EditableInput, _ref);

function EditableInput(props) {
    _classCallCheck(this, EditableInput);

var _this = _possibleConstructorReturn(this, (EditableInput.__proto__ || Object.getPrototypeOf(EditableInput)).call(this));

_this.handleBlur = function () {
      if (_this.state.blurValue) {
        _this.setState({ value: _this.state.blurValue, blurValue: null });
      }
    };

_this.handleChange = function (e) {
      if (_this.props.label) {
        _this.props.onChange && _this.props.onChange(_defineProperty({}, _this.props.label, e.target.value), e);
      } else {
        _this.props.onChange && _this.props.onChange(e.target.value, e);
      }

_this.setState({ value: e.target.value });
    };

_this.handleKeyDown = function (e) {
      // In case `e.target.value` is a percentage remove the `%` character
      // and update accordingly with a percentage
      // https://github.com/casesandberg/react-color/issues/383
      var stringValue = String(e.target.value);
      var isPercentage = stringValue.indexOf('%') > -1;
      var number = Number(stringValue.replace(/%/g, ''));
      if (!isNaN(number)) {
        var amount = _this.props.arrowOffset || 1;

// Up
        if (e.keyCode === 38) {
          if (_this.props.label !== null) {
            _this.props.onChange && _this.props.onChange(_defineProperty({}, _this.props.label, number + amount), e);
          } else {
            _this.props.onChange && _this.props.onChange(number + amount, e);
          }

if (isPercentage) {
            _this.setState({ value: number + amount + '%' });
          } else {
            _this.setState({ value: number + amount });
          }
        }

// Down
        if (e.keyCode === 40) {
          if (_this.props.label !== null) {
            _this.props.onChange && _this.props.onChange(_defineProperty({}, _this.props.label, number - amount), e);
          } else {
            _this.props.onChange && _this.props.onChange(number - amount, e);
          }

if (isPercentage) {
            _this.setState({ value: number - amount + '%' });
          } else {
            _this.setState({ value: number - amount });
          }
        }
      }
    };

_this.handleDrag = function (e) {
      if (_this.props.dragLabel) {
        var newValue = Math.round(_this.props.value + e.movementX);
        if (newValue >= 0 && newValue <= _this.props.dragMax) {
          _this.props.onChange && _this.props.onChange(_defineProperty({}, _this.props.label, newValue), e);
        }
      }
    };

_this.handleMouseDown = function (e) {
      if (_this.props.dragLabel) {
        e.preventDefault();
        _this.handleDrag(e);
        window.addEventListener('mousemove', _this.handleDrag);
        window.addEventListener('mouseup', _this.handleMouseUp);
      }
    };

_this.handleMouseUp = function () {
      _this.unbindEventListeners();
    };

_this.unbindEventListeners = function () {
      window.removeEventListener('mousemove', _this.handleDrag);
      window.removeEventListener('mouseup', _this.handleMouseUp);
    };

_this.state = {
      value: String(props.value).toUpperCase(),
      blurValue: String(props.value).toUpperCase()
    };
    return _this;
  }

_createClass(EditableInput, [{
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      var input = this.input;
      if (nextProps.value !== this.state.value) {
        if (input === document.activeElement) {
          this.setState({ blurValue: String(nextProps.value).toUpperCase() });
        } else {
          this.setState({ value: String(nextProps.value).toUpperCase(), blurValue: !this.state.blurValue && String(nextProps.value).toUpperCase() });
        }
      }
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this.unbindEventListeners();
    }
  }, {
    key: 'render',
    value: function render() {
      var _this2 = this;

var styles = (0, _reactcss2.default)({
        'default': {
          wrap: {
            position: 'relative'
          }
        },
        'user-override': {
          wrap: this.props.style && this.props.style.wrap ? this.props.style.wrap : {},
          input: this.props.style && this.props.style.input ? this.props.style.input : {},
          label: this.props.style && this.props.style.label ? this.props.style.label : {}
        },
        'dragLabel-true': {
          label: {
            cursor: 'ew-resize'
          }
        }
      }, {
        'user-override': true
      }, this.props);

return _react2.default.createElement(
        'div',
        { style: styles.wrap },
        _react2.default.createElement('input', {
          style: styles.input,
          ref: function ref(input) {
            return _this2.input = input;
          },
          value: this.state.value,
          onKeyDown: this.handleKeyDown,
          onChange: this.handleChange,
          onBlur: this.handleBlur,
          placeholder: this.props.placeholder,
          spellCheck: 'false'
        }),
        this.props.label && !this.props.hideLabel ? _react2.default.createElement(
          'span',
          { style: styles.label, onMouseDown: this.handleMouseDown },
          this.props.label
        ) : null
      );
    }
  }]);

return EditableInput;
}(_react.PureComponent || _react.Component);

exports.default = EditableInput;

/***/ }),
/* 1180 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Hue = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _hue = __webpack_require__(1211);

var hue = _interopRequireWildcard(_hue);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Hue = exports.Hue = function (_ref) {
  _inherits(Hue, _ref);

function Hue() {
    var _ref2;

var _temp, _this, _ret;

_classCallCheck(this, Hue);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref2 = Hue.__proto__ || Object.getPrototypeOf(Hue)).call.apply(_ref2, [this].concat(args))), _this), _this.handleChange = function (e, skip) {
      var change = hue.calculateChange(e, skip, _this.props, _this.container);
      change && _this.props.onChange && _this.props.onChange(change, e);
    }, _this.handleMouseDown = function (e) {
      _this.handleChange(e, true);
      window.addEventListener('mousemove', _this.handleChange);
      window.addEventListener('mouseup', _this.handleMouseUp);
    }, _this.handleMouseUp = function () {
      _this.unbindEventListeners();
    }, _temp), _possibleConstructorReturn(_this, _ret);
  }

_createClass(Hue, [{
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this.unbindEventListeners();
    }
  }, {
    key: 'unbindEventListeners',
    value: function unbindEventListeners() {
      window.removeEventListener('mousemove', this.handleChange);
      window.removeEventListener('mouseup', this.handleMouseUp);
    }
  }, {
    key: 'render',
    value: function render() {
      var _this2 = this;

var _props$direction = this.props.direction,
          direction = _props$direction === undefined ? 'horizontal' : _props$direction;

var styles = (0, _reactcss2.default)({
        'default': {
          hue: {
            absolute: '0px 0px 0px 0px',
            borderRadius: this.props.radius,
            boxShadow: this.props.shadow
          },
          container: {
            padding: '0 2px',
            position: 'relative',
            height: '100%',
            borderRadius: this.props.radius
          },
          pointer: {
            position: 'absolute',
            left: this.props.hsl.h * 100 / 360 + '%'
          },
          slider: {
            marginTop: '1px',
            width: '4px',
            borderRadius: '1px',
            height: '8px',
            boxShadow: '0 0 2px rgba(0, 0, 0, .6)',
            background: '#fff',
            transform: 'translateX(-2px)'
          }
        },
        'vertical': {
          pointer: {
            left: '0px',
            top: -(this.props.hsl.h * 100 / 360) + 100 + '%'
          }
        }
      }, { vertical: direction === 'vertical' });

return _react2.default.createElement(
        'div',
        { style: styles.hue },
        _react2.default.createElement(
          'div',
          {
            className: 'hue-' + direction,
            style: styles.container,
            ref: function ref(container) {
              return _this2.container = container;
            },
            onMouseDown: this.handleMouseDown,
            onTouchMove: this.handleChange,
            onTouchStart: this.handleChange
          },
          _react2.default.createElement(
            'style',
            null,
            '\n            .hue-horizontal {\n              background: linear-gradient(to right, #f00 0%, #ff0 17%, #0f0\n                33%, #0ff 50%, #00f 67%, #f0f 83%, #f00 100%);\n              background: -webkit-linear-gradient(to right, #f00 0%, #ff0\n                17%, #0f0 33%, #0ff 50%, #00f 67%, #f0f 83%, #f00 100%);\n            }\n\n            .hue-vertical {\n              background: linear-gradient(to top, #f00 0%, #ff0 17%, #0f0 33%,\n                #0ff 50%, #00f 67%, #f0f 83%, #f00 100%);\n              background: -webkit-linear-gradient(to top, #f00 0%, #ff0 17%,\n                #0f0 33%, #0ff 50%, #00f 67%, #f0f 83%, #f00 100%);\n            }\n          '
          ),
          _react2.default.createElement(
            'div',
            { style: styles.pointer },
            this.props.pointer ? _react2.default.createElement(this.props.pointer, this.props) : _react2.default.createElement('div', { style: styles.slider })
          )
        )
      );
    }
  }]);

return Hue;
}(_react.PureComponent || _react.Component);

exports.default = Hue;

/***/ }),
/* 1181 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Raised = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Raised = exports.Raised = function Raised(_ref) {
  var zDepth = _ref.zDepth,
      radius = _ref.radius,
      background = _ref.background,
      children = _ref.children;

var styles = (0, _reactcss2.default)({
    'default': {
      wrap: {
        position: 'relative',
        display: 'inline-block'
      },
      content: {
        position: 'relative'
      },
      bg: {
        absolute: '0px 0px 0px 0px',
        boxShadow: '0 ' + zDepth + 'px ' + zDepth * 4 + 'px rgba(0,0,0,.24)',
        borderRadius: radius,
        background: background
      }
    },
    'zDepth-0': {
      bg: {
        boxShadow: 'none'
      }
    },

'zDepth-1': {
      bg: {
        boxShadow: '0 2px 10px rgba(0,0,0,.12), 0 2px 5px rgba(0,0,0,.16)'
      }
    },
    'zDepth-2': {
      bg: {
        boxShadow: '0 6px 20px rgba(0,0,0,.19), 0 8px 17px rgba(0,0,0,.2)'
      }
    },
    'zDepth-3': {
      bg: {
        boxShadow: '0 17px 50px rgba(0,0,0,.19), 0 12px 15px rgba(0,0,0,.24)'
      }
    },
    'zDepth-4': {
      bg: {
        boxShadow: '0 25px 55px rgba(0,0,0,.21), 0 16px 28px rgba(0,0,0,.22)'
      }
    },
    'zDepth-5': {
      bg: {
        boxShadow: '0 40px 77px rgba(0,0,0,.22), 0 27px 24px rgba(0,0,0,.2)'
      }
    },
    'square': {
      bg: {
        borderRadius: '0'
      }
    },
    'circle': {
      bg: {
        borderRadius: '50%'
      }
    }
  }, { 'zDepth-1': zDepth === 1 });

return _react2.default.createElement(
    'div',
    { style: styles.wrap },
    _react2.default.createElement('div', { style: styles.bg }),
    _react2.default.createElement(
      'div',
      { style: styles.content },
      children
    )
  );
};

Raised.propTypes = {
  background: _propTypes2.default.string,
  zDepth: _propTypes2.default.oneOf([0, 1, 2, 3, 4, 5]),
  radius: _propTypes2.default.number
};

Raised.defaultProps = {
  background: '#fff',
  zDepth: 1,
  radius: 2
};

exports.default = Raised;

/***/ }),
/* 1182 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Saturation = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _throttle = __webpack_require__(296);

var _throttle2 = _interopRequireDefault(_throttle);

var _saturation = __webpack_require__(1213);

var saturation = _interopRequireWildcard(_saturation);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Saturation = exports.Saturation = function (_ref) {
  _inherits(Saturation, _ref);

function Saturation(props) {
    _classCallCheck(this, Saturation);

var _this = _possibleConstructorReturn(this, (Saturation.__proto__ || Object.getPrototypeOf(Saturation)).call(this, props));

_this.handleChange = function (e, skip) {
      _this.props.onChange && _this.throttle(_this.props.onChange, saturation.calculateChange(e, skip, _this.props, _this.container), e);
    };

_this.handleMouseDown = function (e) {
      _this.handleChange(e, true);
      window.addEventListener('mousemove', _this.handleChange);
      window.addEventListener('mouseup', _this.handleMouseUp);
    };

_this.handleMouseUp = function () {
      _this.unbindEventListeners();
    };

_this.throttle = (0, _throttle2.default)(function (fn, data, e) {
      fn(data, e);
    }, 50);
    return _this;
  }

_createClass(Saturation, [{
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this.unbindEventListeners();
    }
  }, {
    key: 'unbindEventListeners',
    value: function unbindEventListeners() {
      window.removeEventListener('mousemove', this.handleChange);
      window.removeEventListener('mouseup', this.handleMouseUp);
    }
  }, {
    key: 'render',
    value: function render() {
      var _this2 = this;

var _ref2 = this.props.style || {},
          color = _ref2.color,
          white = _ref2.white,
          black = _ref2.black,
          pointer = _ref2.pointer,
          circle = _ref2.circle;

var styles = (0, _reactcss2.default)({
        'default': {
          color: {
            absolute: '0px 0px 0px 0px',
            background: 'hsl(' + this.props.hsl.h + ',100%, 50%)',
            borderRadius: this.props.radius
          },
          white: {
            absolute: '0px 0px 0px 0px',
            borderRadius: this.props.radius
          },
          black: {
            absolute: '0px 0px 0px 0px',
            boxShadow: this.props.shadow,
            borderRadius: this.props.radius
          },
          pointer: {
            position: 'absolute',
            top: -(this.props.hsv.v * 100) + 100 + '%',
            left: this.props.hsv.s * 100 + '%',
            cursor: 'default'
          },
          circle: {
            width: '4px',
            height: '4px',
            boxShadow: '0 0 0 1.5px #fff, inset 0 0 1px 1px rgba(0,0,0,.3),\n            0 0 1px 2px rgba(0,0,0,.4)',
            borderRadius: '50%',
            cursor: 'hand',
            transform: 'translate(-2px, -2px)'
          }
        },
        'custom': {
          color: color,
          white: white,
          black: black,
          pointer: pointer,
          circle: circle
        }
      }, { 'custom': !!this.props.style });

return _react2.default.createElement(
        'div',
        {
          style: styles.color,
          ref: function ref(container) {
            return _this2.container = container;
          },
          onMouseDown: this.handleMouseDown,
          onTouchMove: this.handleChange,
          onTouchStart: this.handleChange
        },
        _react2.default.createElement(
          'style',
          null,
          '\n          .saturation-white {\n            background: -webkit-linear-gradient(to right, #fff, rgba(255,255,255,0));\n            background: linear-gradient(to right, #fff, rgba(255,255,255,0));\n          }\n          .saturation-black {\n            background: -webkit-linear-gradient(to top, #000, rgba(0,0,0,0));\n            background: linear-gradient(to top, #000, rgba(0,0,0,0));\n          }\n        '
        ),
        _react2.default.createElement(
          'div',
          { style: styles.white, className: 'saturation-white' },
          _react2.default.createElement('div', { style: styles.black, className: 'saturation-black' }),
          _react2.default.createElement(
            'div',
            { style: styles.pointer },
            this.props.pointer ? _react2.default.createElement(this.props.pointer, this.props) : _react2.default.createElement('div', { style: styles.circle })
          )
        )
      );
    }
  }]);

return Saturation;
}(_react.PureComponent || _react.Component);

exports.default = Saturation;

/***/ }),
/* 1183 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Swatch = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _interaction = __webpack_require__(1212);

var _ = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ENTER = 13;

var Swatch = exports.Swatch = function Swatch(_ref) {
  var color = _ref.color,
      style = _ref.style,
      _ref$onClick = _ref.onClick,
      onClick = _ref$onClick === undefined ? function () {} : _ref$onClick,
      onHover = _ref.onHover,
      _ref$title = _ref.title,
      title = _ref$title === undefined ? color : _ref$title,
      children = _ref.children,
      focus = _ref.focus,
      _ref$focusStyle = _ref.focusStyle,
      focusStyle = _ref$focusStyle === undefined ? {} : _ref$focusStyle;

var transparent = color === 'transparent';
  var styles = (0, _reactcss2.default)({
    default: {
      swatch: _extends({
        background: color,
        height: '100%',
        width: '100%',
        cursor: 'pointer',
        position: 'relative',
        outline: 'none'
      }, style, focus ? focusStyle : {})
    }
  });

var optionalEvents = {};
  if (onHover) {
    optionalEvents.onMouseOver = handleHover;
  }

return _react2.default.createElement(
    'div',
    _extends({
      style: styles.swatch,
      onClick: handleClick,
      title: title,
      tabIndex: 0,
      onKeyDown: handleKeyDown
    }, optionalEvents),
    children,
    transparent && _react2.default.createElement(_.Checkboard, {
      borderRadius: styles.swatch.borderRadius,
      boxShadow: 'inset 0 0 0 1px rgba(0,0,0,0.1)'
    })
  );
};

exports.default = (0, _interaction.handleFocus)(Swatch);

/***/ }),
/* 1184 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Compact = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _map = __webpack_require__(74);

var _map2 = _interopRequireDefault(_map);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

var _CompactColor = __webpack_require__(1185);

var _CompactColor2 = _interopRequireDefault(_CompactColor);

var _CompactFields = __webpack_require__(1186);

var _CompactFields2 = _interopRequireDefault(_CompactFields);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Compact = exports.Compact = function Compact(_ref) {
  var onChange = _ref.onChange,
      onSwatchHover = _ref.onSwatchHover,
      colors = _ref.colors,
      hex = _ref.hex,
      rgb = _ref.rgb,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      Compact: {
        background: '#f6f6f6',
        radius: '4px'
      },
      compact: {
        paddingTop: '5px',
        paddingLeft: '5px',
        boxSizing: 'initial',
        width: '240px'
      },
      clear: {
        clear: 'both'
      }
    }
  });

return _react2.default.createElement(
    _common.Raised,
    { style: styles.Compact },
    _react2.default.createElement(
      'div',
      { style: styles.compact, className: 'compact-picker ' + className },
      _react2.default.createElement(
        'div',
        null,
        (0, _map2.default)(colors, function (c) {
          return _react2.default.createElement(_CompactColor2.default, {
            key: c,
            color: c,
            active: c.toLowerCase() === hex,
            onClick: handleChange,
            onSwatchHover: onSwatchHover
          });
        }),
        _react2.default.createElement('div', { style: styles.clear })
      ),
      _react2.default.createElement(_CompactFields2.default, { hex: hex, rgb: rgb, onChange: handleChange })
    )
  );
};

Compact.propTypes = {
  colors: _propTypes2.default.arrayOf(_propTypes2.default.string)
};

Compact.defaultProps = {
  colors: ['#4D4D4D', '#999999', '#FFFFFF', '#F44E3B', '#FE9200', '#FCDC00', '#DBDF00', '#A4DD00', '#68CCCA', '#73D8FF', '#AEA1FF', '#FDA1FF', '#333333', '#808080', '#cccccc', '#D33115', '#E27300', '#FCC400', '#B0BC00', '#68BC00', '#16A5A5', '#009CE0', '#7B64FF', '#FA28FF', '#000000', '#666666', '#B3B3B3', '#9F0500', '#C45100', '#FB9E00', '#808900', '#194D33', '#0C797D', '#0062B1', '#653294', '#AB149E']
};

exports.default = (0, _common.ColorWrap)(Compact);

/***/ }),
/* 1185 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CompactColor = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var CompactColor = exports.CompactColor = function CompactColor(_ref) {
  var color = _ref.color,
      _ref$onClick = _ref.onClick,
      onClick = _ref$onClick === undefined ? function () {} : _ref$onClick,
      onSwatchHover = _ref.onSwatchHover,
      active = _ref.active;

var styles = (0, _reactcss2.default)({
    'default': {
      color: {
        background: color,
        width: '15px',
        height: '15px',
        float: 'left',
        marginRight: '5px',
        marginBottom: '5px',
        position: 'relative',
        cursor: 'pointer'
      },
      dot: {
        absolute: '5px 5px 5px 5px',
        background: _color2.default.getContrastingColor(color),
        borderRadius: '50%',
        opacity: '0'
      }
    },
    'active': {
      dot: {
        opacity: '1'
      }
    },
    'color-#FFFFFF': {
      color: {
        boxShadow: 'inset 0 0 0 1px #ddd'
      },
      dot: {
        background: '#000'
      }
    },
    'transparent': {
      dot: {
        background: '#000'
      }
    }
  }, { active: active, 'color-#FFFFFF': color === '#FFFFFF', 'transparent': color === 'transparent' });

return _react2.default.createElement(
    _common.Swatch,
    {
      style: styles.color,
      color: color,
      onClick: onClick,
      onHover: onSwatchHover,
      focusStyle: { boxShadow: '0 0 4px ' + color }
    },
    _react2.default.createElement('div', { style: styles.dot })
  );
};

exports.default = CompactColor;

/***/ }),
/* 1186 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CompactFields = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var CompactFields = exports.CompactFields = function CompactFields(_ref) {
  var hex = _ref.hex,
      rgb = _ref.rgb,
      onChange = _ref.onChange;

var styles = (0, _reactcss2.default)({
    'default': {
      fields: {
        display: 'flex',
        paddingBottom: '6px',
        paddingRight: '5px',
        position: 'relative'
      },
      active: {
        position: 'absolute',
        top: '6px',
        left: '5px',
        height: '9px',
        width: '9px',
        background: hex
      },
      HEXwrap: {
        flex: '6',
        position: 'relative'
      },
      HEXinput: {
        width: '80%',
        padding: '0px',
        paddingLeft: '20%',
        border: 'none',
        outline: 'none',
        background: 'none',
        fontSize: '12px',
        color: '#333',
        height: '16px'
      },
      HEXlabel: {
        display: 'none'
      },
      RGBwrap: {
        flex: '3',
        position: 'relative'
      },
      RGBinput: {
        width: '70%',
        padding: '0px',
        paddingLeft: '30%',
        border: 'none',
        outline: 'none',
        background: 'none',
        fontSize: '12px',
        color: '#333',
        height: '16px'
      },
      RGBlabel: {
        position: 'absolute',
        top: '3px',
        left: '0px',
        lineHeight: '16px',
        textTransform: 'uppercase',
        fontSize: '12px',
        color: '#999'
      }
    }
  });

return _react2.default.createElement(
    'div',
    { style: styles.fields, className: 'flexbox-fix' },
    _react2.default.createElement('div', { style: styles.active }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.HEXwrap, input: styles.HEXinput, label: styles.HEXlabel },
      label: 'hex',
      value: hex,
      onChange: handleChange
    }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 'r',
      value: rgb.r,
      onChange: handleChange
    }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 'g',
      value: rgb.g,
      onChange: handleChange
    }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 'b',
      value: rgb.b,
      onChange: handleChange
    })
  );
};

exports.default = CompactFields;

/***/ }),
/* 1187 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Github = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _map = __webpack_require__(74);

var _map2 = _interopRequireDefault(_map);

var _common = __webpack_require__(25);

var _GithubSwatch = __webpack_require__(1188);

var _GithubSwatch2 = _interopRequireDefault(_GithubSwatch);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Github = exports.Github = function Github(_ref) {
  var width = _ref.width,
      colors = _ref.colors,
      onChange = _ref.onChange,
      onSwatchHover = _ref.onSwatchHover,
      triangle = _ref.triangle,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      card: {
        width: width,
        background: '#fff',
        border: '1px solid rgba(0,0,0,0.2)',
        boxShadow: '0 3px 12px rgba(0,0,0,0.15)',
        borderRadius: '4px',
        position: 'relative',
        padding: '5px',
        display: 'flex',
        flexWrap: 'wrap'
      },
      triangle: {
        position: 'absolute',
        border: '7px solid transparent',
        borderBottomColor: '#fff'
      },
      triangleShadow: {
        position: 'absolute',
        border: '8px solid transparent',
        borderBottomColor: 'rgba(0,0,0,0.15)'
      }
    },
    'hide-triangle': {
      triangle: {
        display: 'none'
      },
      triangleShadow: {
        display: 'none'
      }
    },
    'top-left-triangle': {
      triangle: {
        top: '-14px',
        left: '10px'
      },
      triangleShadow: {
        top: '-16px',
        left: '9px'
      }
    },
    'top-right-triangle': {
      triangle: {
        top: '-14px',
        right: '10px'
      },
      triangleShadow: {
        top: '-16px',
        right: '9px'
      }
    },
    'bottom-left-triangle': {
      triangle: {
        top: '35px',
        left: '10px',
        transform: 'rotate(180deg)'
      },
      triangleShadow: {
        top: '37px',
        left: '9px',
        transform: 'rotate(180deg)'
      }
    },
    'bottom-right-triangle': {
      triangle: {
        top: '35px',
        right: '10px',
        transform: 'rotate(180deg)'
      },
      triangleShadow: {
        top: '37px',
        right: '9px',
        transform: 'rotate(180deg)'
      }
    }
  }, {
    'hide-triangle': triangle === 'hide',
    'top-left-triangle': triangle === 'top-left',
    'top-right-triangle': triangle === 'top-right',
    'bottom-left-triangle': triangle == 'bottom-left',
    'bottom-right-triangle': triangle === 'bottom-right'
  });

var handleChange = function handleChange(hex, e) {
    return onChange({ hex: hex, source: 'hex' }, e);
  };

return _react2.default.createElement(
    'div',
    { style: styles.card, className: 'github-picker ' + className },
    _react2.default.createElement('div', { style: styles.triangleShadow }),
    _react2.default.createElement('div', { style: styles.triangle }),
    (0, _map2.default)(colors, function (c) {
      return _react2.default.createElement(_GithubSwatch2.default, {
        color: c,
        key: c,
        onClick: handleChange,
        onSwatchHover: onSwatchHover
      });
    })
  );
};

Github.propTypes = {
  width: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
  colors: _propTypes2.default.arrayOf(_propTypes2.default.string),
  triangle: _propTypes2.default.oneOf(['hide', 'top-left', 'top-right', 'bottom-left', 'bottom-right'])
};

Github.defaultProps = {
  width: 200,
  colors: ['#B80000', '#DB3E00', '#FCCB00', '#008B02', '#006B76', '#1273DE', '#004DCF', '#5300EB', '#EB9694', '#FAD0C3', '#FEF3BD', '#C1E1C5', '#BEDADC', '#C4DEF6', '#BED3F3', '#D4C4FB'],
  triangle: 'top-left'
};

exports.default = (0, _common.ColorWrap)(Github);

/***/ }),
/* 1188 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.GithubSwatch = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var GithubSwatch = exports.GithubSwatch = function GithubSwatch(_ref) {
  var hover = _ref.hover,
      color = _ref.color,
      onClick = _ref.onClick,
      onSwatchHover = _ref.onSwatchHover;

var hoverSwatch = {
    position: 'relative',
    zIndex: '2',
    outline: '2px solid #fff',
    boxShadow: '0 0 5px 2px rgba(0,0,0,0.25)'
  };

var styles = (0, _reactcss2.default)({
    'default': {
      swatch: {
        width: '25px',
        height: '25px',
        fontSize: '0'
      }
    },
    'hover': {
      swatch: hoverSwatch
    }
  }, { hover: hover });

return _react2.default.createElement(
    'div',
    { style: styles.swatch },
    _react2.default.createElement(_common.Swatch, {
      color: color,
      onClick: onClick,
      onHover: onSwatchHover,
      focusStyle: hoverSwatch
    })
  );
};

exports.default = (0, _reactcss.handleHover)(GithubSwatch);

/***/ }),
/* 1189 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.HuePicker = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

var _HuePointer = __webpack_require__(1190);

var _HuePointer2 = _interopRequireDefault(_HuePointer);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var HuePicker = exports.HuePicker = function HuePicker(_ref) {
  var width = _ref.width,
      height = _ref.height,
      onChange = _ref.onChange,
      hsl = _ref.hsl,
      direction = _ref.direction,
      pointer = _ref.pointer,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        position: 'relative',
        width: width,
        height: height
      },
      hue: {
        radius: '2px'
      }
    }
  });

// Overwrite to provide pure hue color
  var handleChange = function handleChange(data) {
    return onChange({ a: 1, h: data.h, l: 0.5, s: 1 });
  };

return _react2.default.createElement(
    'div',
    { style: styles.picker, className: 'hue-picker ' + className },
    _react2.default.createElement(_common.Hue, _extends({}, styles.hue, {
      hsl: hsl,
      pointer: pointer,
      onChange: handleChange,
      direction: direction
    }))
  );
};

HuePicker.defaultProps = {
  width: '316px',
  height: '16px',
  direction: 'horizontal',
  pointer: _HuePointer2.default
};

exports.default = (0, _common.ColorWrap)(HuePicker);

/***/ }),
/* 1190 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SliderPointer = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var SliderPointer = exports.SliderPointer = function SliderPointer(_ref) {
  var direction = _ref.direction;

return _react2.default.createElement('div', { style: styles.picker });
};

exports.default = SliderPointer;

/***/ }),
/* 1191 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Material = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Material = exports.Material = function Material(_ref) {
  var onChange = _ref.onChange,
      hex = _ref.hex,
      rgb = _ref.rgb,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      material: {
        width: '98px',
        height: '98px',
        padding: '16px',
        fontFamily: 'Roboto'
      },
      HEXwrap: {
        position: 'relative'
      },
      HEXinput: {
        width: '100%',
        marginTop: '12px',
        fontSize: '15px',
        color: '#333',
        padding: '0px',
        border: '0px',
        borderBottom: '2px solid ' + hex,
        outline: 'none',
        height: '30px'
      },
      HEXlabel: {
        position: 'absolute',
        top: '0px',
        left: '0px',
        fontSize: '11px',
        color: '#999999',
        textTransform: 'capitalize'
      },
      Hex: {
        style: {}
      },
      RGBwrap: {
        position: 'relative'
      },
      RGBinput: {
        width: '100%',
        marginTop: '12px',
        fontSize: '15px',
        color: '#333',
        padding: '0px',
        border: '0px',
        borderBottom: '1px solid #eee',
        outline: 'none',
        height: '30px'
      },
      RGBlabel: {
        position: 'absolute',
        top: '0px',
        left: '0px',
        fontSize: '11px',
        color: '#999999',
        textTransform: 'capitalize'
      },
      split: {
        display: 'flex',
        marginRight: '-10px',
        paddingTop: '11px'
      },
      third: {
        flex: '1',
        paddingRight: '10px'
      }
    }
  });

return _react2.default.createElement(
    _common.Raised,
    null,
    _react2.default.createElement(
      'div',
      { style: styles.material, className: 'material-picker ' + className },
      _react2.default.createElement(_common.EditableInput, {
        style: { wrap: styles.HEXwrap, input: styles.HEXinput, label: styles.HEXlabel },
        label: 'hex',
        value: hex,
        onChange: handleChange
      }),
      _react2.default.createElement(
        'div',
        { style: styles.split, className: 'flexbox-fix' },
        _react2.default.createElement(
          'div',
          { style: styles.third },
          _react2.default.createElement(_common.EditableInput, {
            style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
            label: 'r', value: rgb.r,
            onChange: handleChange
          })
        ),
        _react2.default.createElement(
          'div',
          { style: styles.third },
          _react2.default.createElement(_common.EditableInput, {
            style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
            label: 'g',
            value: rgb.g,
            onChange: handleChange
          })
        ),
        _react2.default.createElement(
          'div',
          { style: styles.third },
          _react2.default.createElement(_common.EditableInput, {
            style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
            label: 'b',
            value: rgb.b,
            onChange: handleChange
          })
        )
      )
    )
  );
};

exports.default = (0, _common.ColorWrap)(Material);

/***/ }),
/* 1192 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Photoshop = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

var _PhotoshopFields = __webpack_require__(1194);

var _PhotoshopFields2 = _interopRequireDefault(_PhotoshopFields);

var _PhotoshopPointerCircle = __webpack_require__(1196);

var _PhotoshopPointerCircle2 = _interopRequireDefault(_PhotoshopPointerCircle);

var _PhotoshopPointer = __webpack_require__(1195);

var _PhotoshopPointer2 = _interopRequireDefault(_PhotoshopPointer);

var _PhotoshopButton = __webpack_require__(1193);

var _PhotoshopButton2 = _interopRequireDefault(_PhotoshopButton);

var _PhotoshopPreviews = __webpack_require__(1197);

var _PhotoshopPreviews2 = _interopRequireDefault(_PhotoshopPreviews);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Photoshop = exports.Photoshop = function (_React$Component) {
  _inherits(Photoshop, _React$Component);

function Photoshop(props) {
    _classCallCheck(this, Photoshop);

var _this = _possibleConstructorReturn(this, (Photoshop.__proto__ || Object.getPrototypeOf(Photoshop)).call(this));

_this.state = {
      currentColor: props.hex
    };
    return _this;
  }

_createClass(Photoshop, [{
    key: 'render',
    value: function render() {
      var _props$className = this.props.className,
          className = _props$className === undefined ? '' : _props$className;

var styles = (0, _reactcss2.default)({
        'default': {
          picker: {
            background: '#DCDCDC',
            borderRadius: '4px',
            boxShadow: '0 0 0 1px rgba(0,0,0,.25), 0 8px 16px rgba(0,0,0,.15)',
            boxSizing: 'initial',
            width: '513px'
          },
          head: {
            backgroundImage: 'linear-gradient(-180deg, #F0F0F0 0%, #D4D4D4 100%)',
            borderBottom: '1px solid #B1B1B1',
            boxShadow: 'inset 0 1px 0 0 rgba(255,255,255,.2), inset 0 -1px 0 0 rgba(0,0,0,.02)',
            height: '23px',
            lineHeight: '24px',
            borderRadius: '4px 4px 0 0',
            fontSize: '13px',
            color: '#4D4D4D',
            textAlign: 'center'
          },
          body: {
            padding: '15px 15px 0',
            display: 'flex'
          },
          saturation: {
            width: '256px',
            height: '256px',
            position: 'relative',
            border: '2px solid #B3B3B3',
            borderBottom: '2px solid #F0F0F0',
            overflow: 'hidden'
          },
          hue: {
            position: 'relative',
            height: '256px',
            width: '19px',
            marginLeft: '10px',
            border: '2px solid #B3B3B3',
            borderBottom: '2px solid #F0F0F0'
          },
          controls: {
            width: '180px',
            marginLeft: '10px'
          },
          top: {
            display: 'flex'
          },
          previews: {
            width: '60px'
          },
          actions: {
            flex: '1',
            marginLeft: '20px'
          }
        }
      });

return _react2.default.createElement(
        'div',
        { style: styles.picker, className: 'photoshop-picker ' + className },
        _react2.default.createElement(
          'div',
          { style: styles.head },
          this.props.header
        ),
        _react2.default.createElement(
          'div',
          { style: styles.body, className: 'flexbox-fix' },
          _react2.default.createElement(
            'div',
            { style: styles.saturation },
            _react2.default.createElement(_common.Saturation, {
              hsl: this.props.hsl,
              hsv: this.props.hsv,
              pointer: _PhotoshopPointerCircle2.default,
              onChange: this.props.onChange
            })
          ),
          _react2.default.createElement(
            'div',
            { style: styles.hue },
            _react2.default.createElement(_common.Hue, {
              direction: 'vertical',
              hsl: this.props.hsl,
              pointer: _PhotoshopPointer2.default,
              onChange: this.props.onChange
            })
          ),
          _react2.default.createElement(
            'div',
            { style: styles.controls },
            _react2.default.createElement(
              'div',
              { style: styles.top, className: 'flexbox-fix' },
              _react2.default.createElement(
                'div',
                { style: styles.previews },
                _react2.default.createElement(_PhotoshopPreviews2.default, {
                  rgb: this.props.rgb,
                  currentColor: this.state.currentColor
                })
              ),
              _react2.default.createElement(
                'div',
                { style: styles.actions },
                _react2.default.createElement(_PhotoshopButton2.default, { label: 'OK', onClick: this.props.onAccept, active: true }),
                _react2.default.createElement(_PhotoshopButton2.default, { label: 'Cancel', onClick: this.props.onCancel }),
                _react2.default.createElement(_PhotoshopFields2.default, {
                  onChange: this.props.onChange,
                  rgb: this.props.rgb,
                  hsv: this.props.hsv,
                  hex: this.props.hex
                })
              )
            )
          )
        )
      );
    }
  }]);

return Photoshop;
}(_react2.default.Component);

Photoshop.propTypes = {
  header: _propTypes2.default.string
};

Photoshop.defaultProps = {
  header: 'Color Picker'
};

exports.default = (0, _common.ColorWrap)(Photoshop);

/***/ }),
/* 1193 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PhotoshopBotton = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var PhotoshopBotton = exports.PhotoshopBotton = function PhotoshopBotton(_ref) {
  var onClick = _ref.onClick,
      label = _ref.label,
      children = _ref.children,
      active = _ref.active;

var styles = (0, _reactcss2.default)({
    'default': {
      button: {
        backgroundImage: 'linear-gradient(-180deg, #FFFFFF 0%, #E6E6E6 100%)',
        border: '1px solid #878787',
        borderRadius: '2px',
        height: '20px',
        boxShadow: '0 1px 0 0 #EAEAEA',
        fontSize: '14px',
        color: '#000',
        lineHeight: '20px',
        textAlign: 'center',
        marginBottom: '10px',
        cursor: 'pointer'
      }
    },
    'active': {
      button: {
        boxShadow: '0 0 0 1px #878787'
      }
    }
  }, { active: active });

return _react2.default.createElement(
    'div',
    { style: styles.button, onClick: onClick },
    label || children
  );
};

exports.default = PhotoshopBotton;

/***/ }),
/* 1194 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PhotoshopPicker = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var PhotoshopPicker = exports.PhotoshopPicker = function PhotoshopPicker(_ref) {
  var onChange = _ref.onChange,
      rgb = _ref.rgb,
      hsv = _ref.hsv,
      hex = _ref.hex;

var styles = (0, _reactcss2.default)({
    'default': {
      fields: {
        paddingTop: '5px',
        paddingBottom: '9px',
        width: '80px',
        position: 'relative'
      },
      divider: {
        height: '5px'
      },
      RGBwrap: {
        position: 'relative'
      },
      RGBinput: {
        marginLeft: '40%',
        width: '40%',
        height: '18px',
        border: '1px solid #888888',
        boxShadow: 'inset 0 1px 1px rgba(0,0,0,.1), 0 1px 0 0 #ECECEC',
        marginBottom: '5px',
        fontSize: '13px',
        paddingLeft: '3px',
        marginRight: '10px'
      },
      RGBlabel: {
        left: '0px',
        width: '34px',
        textTransform: 'uppercase',
        fontSize: '13px',
        height: '18px',
        lineHeight: '22px',
        position: 'absolute'
      },
      HEXwrap: {
        position: 'relative'
      },
      HEXinput: {
        marginLeft: '20%',
        width: '80%',
        height: '18px',
        border: '1px solid #888888',
        boxShadow: 'inset 0 1px 1px rgba(0,0,0,.1), 0 1px 0 0 #ECECEC',
        marginBottom: '6px',
        fontSize: '13px',
        paddingLeft: '3px'
      },
      HEXlabel: {
        position: 'absolute',
        top: '0px',
        left: '0px',
        width: '14px',
        textTransform: 'uppercase',
        fontSize: '13px',
        height: '18px',
        lineHeight: '22px'
      },
      fieldSymbols: {
        position: 'absolute',
        top: '5px',
        right: '-7px',
        fontSize: '13px'
      },
      symbol: {
        height: '20px',
        lineHeight: '22px',
        paddingBottom: '7px'
      }
    }
  });

return _react2.default.createElement(
    'div',
    { style: styles.fields },
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 'h',
      value: Math.round(hsv.h),
      onChange: handleChange
    }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 's',
      value: Math.round(hsv.s * 100),
      onChange: handleChange
    }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 'v',
      value: Math.round(hsv.v * 100),
      onChange: handleChange
    }),
    _react2.default.createElement('div', { style: styles.divider }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 'r',
      value: rgb.r,
      onChange: handleChange
    }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 'g',
      value: rgb.g,
      onChange: handleChange
    }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.RGBwrap, input: styles.RGBinput, label: styles.RGBlabel },
      label: 'b',
      value: rgb.b,
      onChange: handleChange
    }),
    _react2.default.createElement('div', { style: styles.divider }),
    _react2.default.createElement(_common.EditableInput, {
      style: { wrap: styles.HEXwrap, input: styles.HEXinput, label: styles.HEXlabel },
      label: '#',
      value: hex.replace('#', ''),
      onChange: handleChange
    }),
    _react2.default.createElement(
      'div',
      { style: styles.fieldSymbols },
      _react2.default.createElement(
        'div',
        { style: styles.symbol },
        '\xB0'
      ),
      _react2.default.createElement(
        'div',
        { style: styles.symbol },
        '%'
      ),
      _react2.default.createElement(
        'div',
        { style: styles.symbol },
        '%'
      )
    )
  );
};

exports.default = PhotoshopPicker;

/***/ }),
/* 1195 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PhotoshopPointerCircle = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var PhotoshopPointerCircle = exports.PhotoshopPointerCircle = function PhotoshopPointerCircle() {
  var styles = (0, _reactcss2.default)({
    'default': {
      triangle: {
        width: 0,
        height: 0,
        borderStyle: 'solid',
        borderWidth: '4px 0 4px 6px',
        borderColor: 'transparent transparent transparent #fff',
        position: 'absolute',
        top: '1px',
        left: '1px'
      },
      triangleBorder: {
        width: 0,
        height: 0,
        borderStyle: 'solid',
        borderWidth: '5px 0 5px 8px',
        borderColor: 'transparent transparent transparent #555'
      },

left: {
        Extend: 'triangleBorder',
        transform: 'translate(-13px, -4px)'
      },
      leftInside: {
        Extend: 'triangle',
        transform: 'translate(-8px, -5px)'
      },

right: {
        Extend: 'triangleBorder',
        transform: 'translate(20px, -14px) rotate(180deg)'
      },
      rightInside: {
        Extend: 'triangle',
        transform: 'translate(-8px, -5px)'
      }
    }
  });

return _react2.default.createElement(
    'div',
    { style: styles.pointer },
    _react2.default.createElement(
      'div',
      { style: styles.left },
      _react2.default.createElement('div', { style: styles.leftInside })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.right },
      _react2.default.createElement('div', { style: styles.rightInside })
    )
  );
};

exports.default = PhotoshopPointerCircle;

/***/ }),
/* 1196 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PhotoshopPointerCircle = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var PhotoshopPointerCircle = exports.PhotoshopPointerCircle = function PhotoshopPointerCircle(_ref) {
  var hsl = _ref.hsl;

var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        width: '12px',
        height: '12px',
        borderRadius: '6px',
        boxShadow: 'inset 0 0 0 1px #fff',
        transform: 'translate(-6px, -6px)'
      }
    },
    'black-outline': {
      picker: {
        boxShadow: 'inset 0 0 0 1px #000'
      }
    }
  }, { 'black-outline': hsl.l > 0.5 });

return _react2.default.createElement('div', { style: styles.picker });
};

exports.default = PhotoshopPointerCircle;

/***/ }),
/* 1197 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PhotoshopPreviews = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var PhotoshopPreviews = exports.PhotoshopPreviews = function PhotoshopPreviews(_ref) {
  var rgb = _ref.rgb,
      currentColor = _ref.currentColor;

var styles = (0, _reactcss2.default)({
    'default': {
      swatches: {
        border: '1px solid #B3B3B3',
        borderBottom: '1px solid #F0F0F0',
        marginBottom: '2px',
        marginTop: '1px'
      },
      new: {
        height: '34px',
        background: 'rgb(' + rgb.r + ',' + rgb.g + ', ' + rgb.b + ')',
        boxShadow: 'inset 1px 0 0 #000, inset -1px 0 0 #000, inset 0 1px 0 #000'
      },
      current: {
        height: '34px',
        background: currentColor,
        boxShadow: 'inset 1px 0 0 #000, inset -1px 0 0 #000, inset 0 -1px 0 #000'
      },
      label: {
        fontSize: '14px',
        color: '#000',
        textAlign: 'center'
      }
    }
  });

return _react2.default.createElement(
    'div',
    null,
    _react2.default.createElement(
      'div',
      { style: styles.label },
      'new'
    ),
    _react2.default.createElement(
      'div',
      { style: styles.swatches },
      _react2.default.createElement('div', { style: styles.new }),
      _react2.default.createElement('div', { style: styles.current })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.label },
      'current'
    )
  );
};

exports.default = PhotoshopPreviews;

/***/ }),
/* 1198 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Sketch = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

var _SketchFields = __webpack_require__(1199);

var _SketchFields2 = _interopRequireDefault(_SketchFields);

var _SketchPresetColors = __webpack_require__(1200);

var _SketchPresetColors2 = _interopRequireDefault(_SketchPresetColors);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Sketch = exports.Sketch = function Sketch(_ref) {
  var width = _ref.width,
      rgb = _ref.rgb,
      hex = _ref.hex,
      hsv = _ref.hsv,
      hsl = _ref.hsl,
      onChange = _ref.onChange,
      onSwatchHover = _ref.onSwatchHover,
      disableAlpha = _ref.disableAlpha,
      presetColors = _ref.presetColors,
      renderers = _ref.renderers,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        width: width,
        padding: '10px 10px 0',
        boxSizing: 'initial',
        background: '#fff',
        borderRadius: '4px',
        boxShadow: '0 0 0 1px rgba(0,0,0,.15), 0 8px 16px rgba(0,0,0,.15)'
      },
      saturation: {
        width: '100%',
        paddingBottom: '75%',
        position: 'relative',
        overflow: 'hidden'
      },
      Saturation: {
        radius: '3px',
        shadow: 'inset 0 0 0 1px rgba(0,0,0,.15), inset 0 0 4px rgba(0,0,0,.25)'
      },
      controls: {
        display: 'flex'
      },
      sliders: {
        padding: '4px 0',
        flex: '1'
      },
      color: {
        width: '24px',
        height: '24px',
        position: 'relative',
        marginTop: '4px',
        marginLeft: '4px',
        borderRadius: '3px'
      },
      activeColor: {
        absolute: '0px 0px 0px 0px',
        borderRadius: '2px',
        background: 'rgba(' + rgb.r + ',' + rgb.g + ',' + rgb.b + ',' + rgb.a + ')',
        boxShadow: 'inset 0 0 0 1px rgba(0,0,0,.15), inset 0 0 4px rgba(0,0,0,.25)'
      },
      hue: {
        position: 'relative',
        height: '10px',
        overflow: 'hidden'
      },
      Hue: {
        radius: '2px',
        shadow: 'inset 0 0 0 1px rgba(0,0,0,.15), inset 0 0 4px rgba(0,0,0,.25)'
      },

alpha: {
        position: 'relative',
        height: '10px',
        marginTop: '4px',
        overflow: 'hidden'
      },
      Alpha: {
        radius: '2px',
        shadow: 'inset 0 0 0 1px rgba(0,0,0,.15), inset 0 0 4px rgba(0,0,0,.25)'
      }
    },
    'disableAlpha': {
      color: {
        height: '10px'
      },
      hue: {
        height: '10px'
      },
      alpha: {
        display: 'none'
      }
    }
  }, { disableAlpha: disableAlpha });

return _react2.default.createElement(
    'div',
    { style: styles.picker, className: 'sketch-picker ' + className },
    _react2.default.createElement(
      'div',
      { style: styles.saturation },
      _react2.default.createElement(_common.Saturation, {
        style: styles.Saturation,
        hsl: hsl,
        hsv: hsv,
        onChange: onChange
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.controls, className: 'flexbox-fix' },
      _react2.default.createElement(
        'div',
        { style: styles.sliders },
        _react2.default.createElement(
          'div',
          { style: styles.hue },
          _react2.default.createElement(_common.Hue, {
            style: styles.Hue,
            hsl: hsl,
            onChange: onChange
          })
        ),
        _react2.default.createElement(
          'div',
          { style: styles.alpha },
          _react2.default.createElement(_common.Alpha, {
            style: styles.Alpha,
            rgb: rgb,
            hsl: hsl,
            renderers: renderers,
            onChange: onChange
          })
        )
      ),
      _react2.default.createElement(
        'div',
        { style: styles.color },
        _react2.default.createElement(_common.Checkboard, null),
        _react2.default.createElement('div', { style: styles.activeColor })
      )
    ),
    _react2.default.createElement(_SketchFields2.default, {
      rgb: rgb,
      hsl: hsl,
      hex: hex,
      onChange: onChange,
      disableAlpha: disableAlpha
    }),
    _react2.default.createElement(_SketchPresetColors2.default, {
      colors: presetColors,
      onClick: onChange,
      onSwatchHover: onSwatchHover
    })
  );
};

Sketch.propTypes = {
  disableAlpha: _propTypes2.default.bool,
  width: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number])
};

Sketch.defaultProps = {
  disableAlpha: false,
  width: 200,
  presetColors: ['#D0021B', '#F5A623', '#F8E71C', '#8B572A', '#7ED321', '#417505', '#BD10E0', '#9013FE', '#4A90E2', '#50E3C2', '#B8E986', '#000000', '#4A4A4A', '#9B9B9B', '#FFFFFF']
};

exports.default = (0, _common.ColorWrap)(Sketch);

/***/ }),
/* 1199 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SketchFields = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/* eslint-disable no-param-reassign */

var SketchFields = exports.SketchFields = function SketchFields(_ref) {
  var onChange = _ref.onChange,
      rgb = _ref.rgb,
      hsl = _ref.hsl,
      hex = _ref.hex,
      disableAlpha = _ref.disableAlpha;

var styles = (0, _reactcss2.default)({
    'default': {
      fields: {
        display: 'flex',
        paddingTop: '4px'
      },
      single: {
        flex: '1',
        paddingLeft: '6px'
      },
      alpha: {
        flex: '1',
        paddingLeft: '6px'
      },
      double: {
        flex: '2'
      },
      input: {
        width: '80%',
        padding: '4px 10% 3px',
        border: 'none',
        boxShadow: 'inset 0 0 0 1px #ccc',
        fontSize: '11px'
      },
      label: {
        display: 'block',
        textAlign: 'center',
        fontSize: '11px',
        color: '#222',
        paddingTop: '3px',
        paddingBottom: '4px',
        textTransform: 'capitalize'
      }
    },
    'disableAlpha': {
      alpha: {
        display: 'none'
      }
    }
  }, { disableAlpha: disableAlpha });

data.a /= 100;
      onChange({
        h: hsl.h,
        s: hsl.s,
        l: hsl.l,
        a: data.a,
        source: 'rgb'
      }, e);
    }
  };

return _react2.default.createElement(
    'div',
    { style: styles.fields, className: 'flexbox-fix' },
    _react2.default.createElement(
      'div',
      { style: styles.double },
      _react2.default.createElement(_common.EditableInput, {
        style: { input: styles.input, label: styles.label },
        label: 'hex',
        value: hex.replace('#', ''),
        onChange: handleChange
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.single },
      _react2.default.createElement(_common.EditableInput, {
        style: { input: styles.input, label: styles.label },
        label: 'r',
        value: rgb.r,
        onChange: handleChange,
        dragLabel: 'true',
        dragMax: '255'
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.single },
      _react2.default.createElement(_common.EditableInput, {
        style: { input: styles.input, label: styles.label },
        label: 'g',
        value: rgb.g,
        onChange: handleChange,
        dragLabel: 'true',
        dragMax: '255'
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.single },
      _react2.default.createElement(_common.EditableInput, {
        style: { input: styles.input, label: styles.label },
        label: 'b',
        value: rgb.b,
        onChange: handleChange,
        dragLabel: 'true',
        dragMax: '255'
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.alpha },
      _react2.default.createElement(_common.EditableInput, {
        style: { input: styles.input, label: styles.label },
        label: 'a',
        value: Math.round(rgb.a * 100),
        onChange: handleChange,
        dragLabel: 'true',
        dragMax: '100'
      })
    )
  );
};

exports.default = SketchFields;

/***/ }),
/* 1200 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SketchPresetColors = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var SketchPresetColors = exports.SketchPresetColors = function SketchPresetColors(_ref) {
  var colors = _ref.colors,
      _ref$onClick = _ref.onClick,
      onClick = _ref$onClick === undefined ? function () {} : _ref$onClick,
      onSwatchHover = _ref.onSwatchHover;

var styles = (0, _reactcss2.default)({
    'default': {
      colors: {
        margin: '0 -10px',
        padding: '10px 0 0 10px',
        borderTop: '1px solid #eee',
        display: 'flex',
        flexWrap: 'wrap',
        position: 'relative'
      },
      swatchWrap: {
        width: '16px',
        height: '16px',
        margin: '0 10px 10px 0'
      },
      swatch: {
        borderRadius: '3px',
        boxShadow: 'inset 0 0 0 1px rgba(0,0,0,.15)'
      }
    },
    'no-presets': {
      colors: {
        display: 'none'
      }
    }
  }, {
    'no-presets': !colors || !colors.length
  });

var handleClick = function handleClick(hex, e) {
    onClick({
      hex: hex,
      source: 'hex'
    }, e);
  };

return _react2.default.createElement(
    'div',
    { style: styles.colors, className: 'flexbox-fix' },
    colors.map(function (colorObjOrString) {
      var c = typeof colorObjOrString === 'string' ? { color: colorObjOrString } : colorObjOrString;
      var key = '' + c.color + (c.title || '');
      return _react2.default.createElement(
        'div',
        { key: key, style: styles.swatchWrap },
        _react2.default.createElement(_common.Swatch, _extends({}, c, {
          style: styles.swatch,
          onClick: handleClick,
          onHover: onSwatchHover,
          focusStyle: {
            boxShadow: 'inset 0 0 0 1px rgba(0,0,0,.15), 0 0 4px ' + c.color
          }
        }))
      );
    })
  );
};

SketchPresetColors.propTypes = {
  colors: _propTypes2.default.arrayOf(_propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.shape({
    color: _propTypes2.default.string,
    title: _propTypes2.default.string
  })])).isRequired
};

exports.default = SketchPresetColors;

/***/ }),
/* 1201 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Slider = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _common = __webpack_require__(25);

var _SliderSwatches = __webpack_require__(1204);

var _SliderSwatches2 = _interopRequireDefault(_SliderSwatches);

var _SliderPointer = __webpack_require__(1202);

var _SliderPointer2 = _interopRequireDefault(_SliderPointer);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Slider = exports.Slider = function Slider(_ref) {
  var hsl = _ref.hsl,
      onChange = _ref.onChange,
      pointer = _ref.pointer,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      hue: {
        height: '12px',
        position: 'relative'
      },
      Hue: {
        radius: '2px'
      }
    }
  });

return _react2.default.createElement(
    'div',
    { className: 'slider-picker ' + className },
    _react2.default.createElement(
      'div',
      { style: styles.hue },
      _react2.default.createElement(_common.Hue, {
        style: styles.Hue,
        hsl: hsl,
        pointer: pointer,
        onChange: onChange
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.swatches },
      _react2.default.createElement(_SliderSwatches2.default, { hsl: hsl, onClick: onChange })
    )
  );
};

Slider.defaultProps = {
  pointer: _SliderPointer2.default
};

exports.default = (0, _common.ColorWrap)(Slider);

/***/ }),
/* 1202 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SliderPointer = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var SliderPointer = exports.SliderPointer = function SliderPointer() {
  var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        width: '14px',
        height: '14px',
        borderRadius: '6px',
        transform: 'translate(-7px, -1px)',
        backgroundColor: 'rgb(248, 248, 248)',
        boxShadow: '0 1px 4px 0 rgba(0, 0, 0, 0.37)'
      }
    }
  });

return _react2.default.createElement('div', { style: styles.picker });
};

exports.default = SliderPointer;

/***/ }),
/* 1203 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SliderSwatch = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var SliderSwatch = exports.SliderSwatch = function SliderSwatch(_ref) {
  var hsl = _ref.hsl,
      offset = _ref.offset,
      _ref$onClick = _ref.onClick,
      onClick = _ref$onClick === undefined ? function () {} : _ref$onClick,
      active = _ref.active,
      first = _ref.first,
      last = _ref.last;

var styles = (0, _reactcss2.default)({
    'default': {
      swatch: {
        height: '12px',
        background: 'hsl(' + hsl.h + ', 50%, ' + offset * 100 + '%)',
        cursor: 'pointer'
      }
    },
    'first': {
      swatch: {
        borderRadius: '2px 0 0 2px'
      }
    },
    'last': {
      swatch: {
        borderRadius: '0 2px 2px 0'
      }
    },
    'active': {
      swatch: {
        transform: 'scaleY(1.8)',
        borderRadius: '3.6px/2px'
      }
    }
  }, { active: active, first: first, last: last });

var handleClick = function handleClick(e) {
    return onClick({
      h: hsl.h,
      s: 0.5,
      l: offset,
      source: 'hsl'
    }, e);
  };

return _react2.default.createElement('div', { style: styles.swatch, onClick: handleClick });
};

exports.default = SliderSwatch;

/***/ }),
/* 1204 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SliderSwatches = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _SliderSwatch = __webpack_require__(1203);

var _SliderSwatch2 = _interopRequireDefault(_SliderSwatch);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var SliderSwatches = exports.SliderSwatches = function SliderSwatches(_ref) {
  var onClick = _ref.onClick,
      hsl = _ref.hsl;

var styles = (0, _reactcss2.default)({
    'default': {
      swatches: {
        marginTop: '20px'
      },
      swatch: {
        boxSizing: 'border-box',
        width: '20%',
        paddingRight: '1px',
        float: 'left'
      },
      clear: {
        clear: 'both'
      }
    }
  });

return _react2.default.createElement(
    'div',
    { style: styles.swatches },
    _react2.default.createElement(
      'div',
      { style: styles.swatch },
      _react2.default.createElement(_SliderSwatch2.default, {
        hsl: hsl,
        offset: '.80',
        active: Math.round(hsl.l * 100) / 100 === 0.80 && Math.round(hsl.s * 100) / 100 === 0.50,
        onClick: onClick,
        first: true
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.swatch },
      _react2.default.createElement(_SliderSwatch2.default, {
        hsl: hsl,
        offset: '.65',
        active: Math.round(hsl.l * 100) / 100 === 0.65 && Math.round(hsl.s * 100) / 100 === 0.50,
        onClick: onClick
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.swatch },
      _react2.default.createElement(_SliderSwatch2.default, {
        hsl: hsl,
        offset: '.50',
        active: Math.round(hsl.l * 100) / 100 === 0.50 && Math.round(hsl.s * 100) / 100 === 0.50,
        onClick: onClick
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.swatch },
      _react2.default.createElement(_SliderSwatch2.default, {
        hsl: hsl,
        offset: '.35',
        active: Math.round(hsl.l * 100) / 100 === 0.35 && Math.round(hsl.s * 100) / 100 === 0.50,
        onClick: onClick
      })
    ),
    _react2.default.createElement(
      'div',
      { style: styles.swatch },
      _react2.default.createElement(_SliderSwatch2.default, {
        hsl: hsl,
        offset: '.20',
        active: Math.round(hsl.l * 100) / 100 === 0.20 && Math.round(hsl.s * 100) / 100 === 0.50,
        onClick: onClick,
        last: true
      })
    ),
    _react2.default.createElement('div', { style: styles.clear })
  );
};

exports.default = SliderSwatches;

/***/ }),
/* 1205 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Swatches = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _map = __webpack_require__(74);

var _map2 = _interopRequireDefault(_map);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _materialColors = __webpack_require__(458);

var material = _interopRequireWildcard(_materialColors);

var _common = __webpack_require__(25);

var _SwatchesGroup = __webpack_require__(1207);

var _SwatchesGroup2 = _interopRequireDefault(_SwatchesGroup);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Swatches = exports.Swatches = function Swatches(_ref) {
  var width = _ref.width,
      height = _ref.height,
      onChange = _ref.onChange,
      onSwatchHover = _ref.onSwatchHover,
      colors = _ref.colors,
      hex = _ref.hex,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      picker: {
        width: width,
        height: height
      },
      overflow: {
        height: height,
        overflowY: 'scroll'
      },
      body: {
        padding: '16px 0 6px 16px'
      },
      clear: {
        clear: 'both'
      }
    }
  });

var handleChange = function handleChange(data, e) {
    _color2.default.isValidHex(data) && onChange({
      hex: data,
      source: 'hex'
    }, e);
  };

return _react2.default.createElement(
    'div',
    { style: styles.picker, className: 'swatches-picker ' + className },
    _react2.default.createElement(
      _common.Raised,
      null,
      _react2.default.createElement(
        'div',
        { style: styles.overflow },
        _react2.default.createElement(
          'div',
          { style: styles.body },
          (0, _map2.default)(colors, function (group) {
            return _react2.default.createElement(_SwatchesGroup2.default, {
              key: group.toString(),
              group: group,
              active: hex,
              onClick: handleChange,
              onSwatchHover: onSwatchHover
            });
          }),
          _react2.default.createElement('div', { style: styles.clear })
        )
      )
    )
  );
};

Swatches.propTypes = {
  width: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
  height: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
  colors: _propTypes2.default.arrayOf(_propTypes2.default.arrayOf(_propTypes2.default.string))

/* eslint-disable max-len */
};Swatches.defaultProps = {
  width: 320,
  height: 240,
  colors: [[material.red['900'], material.red['700'], material.red['500'], material.red['300'], material.red['100']], [material.pink['900'], material.pink['700'], material.pink['500'], material.pink['300'], material.pink['100']], [material.purple['900'], material.purple['700'], material.purple['500'], material.purple['300'], material.purple['100']], [material.deepPurple['900'], material.deepPurple['700'], material.deepPurple['500'], material.deepPurple['300'], material.deepPurple['100']], [material.indigo['900'], material.indigo['700'], material.indigo['500'], material.indigo['300'], material.indigo['100']], [material.blue['900'], material.blue['700'], material.blue['500'], material.blue['300'], material.blue['100']], [material.lightBlue['900'], material.lightBlue['700'], material.lightBlue['500'], material.lightBlue['300'], material.lightBlue['100']], [material.cyan['900'], material.cyan['700'], material.cyan['500'], material.cyan['300'], material.cyan['100']], [material.teal['900'], material.teal['700'], material.teal['500'], material.teal['300'], material.teal['100']], ['#194D33', material.green['700'], material.green['500'], material.green['300'], material.green['100']], [material.lightGreen['900'], material.lightGreen['700'], material.lightGreen['500'], material.lightGreen['300'], material.lightGreen['100']], [material.lime['900'], material.lime['700'], material.lime['500'], material.lime['300'], material.lime['100']], [material.yellow['900'], material.yellow['700'], material.yellow['500'], material.yellow['300'], material.yellow['100']], [material.amber['900'], material.amber['700'], material.amber['500'], material.amber['300'], material.amber['100']], [material.orange['900'], material.orange['700'], material.orange['500'], material.orange['300'], material.orange['100']], [material.deepOrange['900'], material.deepOrange['700'], material.deepOrange['500'], material.deepOrange['300'], material.deepOrange['100']], [material.brown['900'], material.brown['700'], material.brown['500'], material.brown['300'], material.brown['100']], [material.blueGrey['900'], material.blueGrey['700'], material.blueGrey['500'], material.blueGrey['300'], material.blueGrey['100']], ['#000000', '#525252', '#969696', '#D9D9D9', '#FFFFFF']]
};

exports.default = (0, _common.ColorWrap)(Swatches);

/***/ }),
/* 1206 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SwatchesColor = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var SwatchesColor = exports.SwatchesColor = function SwatchesColor(_ref) {
  var color = _ref.color,
      _ref$onClick = _ref.onClick,
      onClick = _ref$onClick === undefined ? function () {} : _ref$onClick,
      onSwatchHover = _ref.onSwatchHover,
      first = _ref.first,
      last = _ref.last,
      active = _ref.active;

var styles = (0, _reactcss2.default)({
    'default': {
      color: {
        width: '40px',
        height: '24px',
        cursor: 'pointer',
        background: color,
        marginBottom: '1px'
      },
      check: {
        fill: _color2.default.getContrastingColor(color),
        marginLeft: '8px',
        display: 'none'
      }
    },
    'first': {
      color: {
        overflow: 'hidden',
        borderRadius: '2px 2px 0 0'
      }
    },
    'last': {
      color: {
        overflow: 'hidden',
        borderRadius: '0 0 2px 2px'
      }
    },
    'active': {
      check: {
        display: 'block'
      }
    },
    'color-#FFFFFF': {
      color: {
        boxShadow: 'inset 0 0 0 1px #ddd'
      },
      check: {
        fill: '#333'
      }
    },
    'transparent': {
      check: {
        fill: '#333'
      }
    }
  }, {
    first: first,
    last: last,
    active: active,
    'color-#FFFFFF': color === '#FFFFFF',
    'transparent': color === 'transparent'
  });

return _react2.default.createElement(
    _common.Swatch,
    {
      color: color,
      style: styles.color,
      onClick: onClick,
      onHover: onSwatchHover,
      focusStyle: { boxShadow: '0 0 4px ' + color }
    },
    _react2.default.createElement(
      'div',
      { style: styles.check },
      _react2.default.createElement(
        'svg',
        { style: { width: '24px', height: '24px' }, viewBox: '0 0 24 24' },
        _react2.default.createElement('path', { d: 'M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z' })
      )
    )
  );
};

exports.default = SwatchesColor;

/***/ }),
/* 1207 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SwatchesGroup = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _map = __webpack_require__(74);

var _map2 = _interopRequireDefault(_map);

var _SwatchesColor = __webpack_require__(1206);

var _SwatchesColor2 = _interopRequireDefault(_SwatchesColor);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var SwatchesGroup = exports.SwatchesGroup = function SwatchesGroup(_ref) {
  var onClick = _ref.onClick,
      onSwatchHover = _ref.onSwatchHover,
      group = _ref.group,
      active = _ref.active;

var styles = (0, _reactcss2.default)({
    'default': {
      group: {
        paddingBottom: '10px',
        width: '40px',
        float: 'left',
        marginRight: '10px'
      }
    }
  });

return _react2.default.createElement(
    'div',
    { style: styles.group },
    (0, _map2.default)(group, function (color, i) {
      return _react2.default.createElement(_SwatchesColor2.default, {
        key: color,
        color: color,
        active: color.toLowerCase() === active,
        first: i === 0,
        last: i === group.length - 1,
        onClick: onClick,
        onSwatchHover: onSwatchHover
      });
    })
  );
};

exports.default = SwatchesGroup;

/***/ }),
/* 1208 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Twitter = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _propTypes = __webpack_require__(6);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _reactcss = __webpack_require__(17);

var _reactcss2 = _interopRequireDefault(_reactcss);

var _map = __webpack_require__(74);

var _map2 = _interopRequireDefault(_map);

var _color = __webpack_require__(49);

var _color2 = _interopRequireDefault(_color);

var _common = __webpack_require__(25);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Twitter = exports.Twitter = function Twitter(_ref) {
  var onChange = _ref.onChange,
      onSwatchHover = _ref.onSwatchHover,
      hex = _ref.hex,
      colors = _ref.colors,
      width = _ref.width,
      triangle = _ref.triangle,
      _ref$className = _ref.className,
      className = _ref$className === undefined ? '' : _ref$className;

var styles = (0, _reactcss2.default)({
    'default': {
      card: {
        width: width,
        background: '#fff',
        border: '0 solid rgba(0,0,0,0.25)',
        boxShadow: '0 1px 4px rgba(0,0,0,0.25)',
        borderRadius: '4px',
        position: 'relative'
      },
      body: {
        padding: '15px 9px 9px 15px'
      },
      label: {
        fontSize: '18px',
        color: '#fff'
      },
      triangle: {
        width: '0px',
        height: '0px',
        borderStyle: 'solid',
        borderWidth: '0 9px 10px 9px',
        borderColor: 'transparent transparent #fff transparent',
        position: 'absolute'
      },
      triangleShadow: {
        width: '0px',
        height: '0px',
        borderStyle: 'solid',
        borderWidth: '0 9px 10px 9px',
        borderColor: 'transparent transparent rgba(0,0,0,.1) transparent',
        position: 'absolute'
      },
      hash: {
        background: '#F0F0F0',
        height: '30px',
        width: '30px',
        borderRadius: '4px 0 0 4px',
        float: 'left',
        color: '#98A1A4',
        display: 'flex',
        alignItems: 'center',
        justifyContent: 'center'
      },
      input: {
        width: '100px',
        fontSize: '14px',
        color: '#666',
        border: '0px',
        outline: 'none',
        height: '28px',
        boxShadow: 'inset 0 0 0 1px #F0F0F0',
        boxSizing: 'content-box',
        borderRadius: '0 4px 4px 0',
        float: 'left',
        paddingLeft: '8px'
      },
      swatch: {
        width: '30px',
        height: '30px',
        float: 'left',
        borderRadius: '4px',
        margin: '0 6px 6px 0'
      },
      clear: {
        clear: 'both'
      }
    },
    'hide-triangle': {
      triangle: {
        display: 'none'
      },
      triangleShadow: {
        display: 'none'
      }
    },
    'top-left-triangle': {
      triangle: {
        top: '-10px',
        left: '12px'
      },
      triangleShadow: {
        top: '-11px',
        left: '12px'
      }
    },
    'top-right-triangle': {
      triangle: {
        top: '-10px',
        right: '12px'
      },
      triangleShadow: {
        top: '-11px',
        right: '12px'
      }
    }
  }, {
    'hide-triangle': triangle === 'hide',
    'top-left-triangle': triangle === 'top-left',
    'top-right-triangle': triangle === 'top-right'
  });

var handleChange = function handleChange(hexcode, e) {
    _color2.default.isValidHex(hexcode) && onChange({
      hex: hexcode,
      source: 'hex'
    }, e);
  };

return _react2.default.createElement(
    'div',
    { style: styles.card, className: 'twitter-picker ' + className },
    _react2.default.createElement('div', { style: styles.triangleShadow }),
    _react2.default.createElement('div', { style: styles.triangle }),
    _react2.default.createElement(
      'div',
      { style: styles.body },
      (0, _map2.default)(colors, function (c, i) {
        return _react2.default.createElement(_common.Swatch, {
          key: i,
          color: c,
          hex: c,
          style: styles.swatch,
          onClick: handleChange,
          onHover: onSwatchHover,
          focusStyle: {
            boxShadow: '0 0 4px ' + c
          }
        });
      }),
      _react2.default.createElement(
        'div',
        { style: styles.hash },
        '#'
      ),
      _react2.default.createElement(_common.EditableInput, {
        style: { input: styles.input },
        value: hex.replace('#', ''),
        onChange: handleChange
      }),
      _react2.default.createElement('div', { style: styles.clear })
    )
  );
};

Twitter.propTypes = {
  width: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
  triangle: _propTypes2.default.oneOf(['hide', 'top-left', 'top-right']),
  colors: _propTypes2.default.arrayOf(_propTypes2.default.string)
};

Twitter.defaultProps = {
  width: 276,
  colors: ['#FF6900', '#FCB900', '#7BDCB5', '#00D084', '#8ED1FC', '#0693E3', '#ABB8C3', '#EB144C', '#F78DA7', '#9900EF'],
  triangle: 'top-left'
};

exports.default = (0, _common.ColorWrap)(Twitter);

/***/ }),
/* 1209 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var calculateChange = exports.calculateChange = function calculateChange(e, skip, props, container) {
  e.preventDefault();
  var containerWidth = container.clientWidth;
  var containerHeight = container.clientHeight;
  var x = typeof e.pageX === 'number' ? e.pageX : e.touches[0].pageX;
  var y = typeof e.pageY === 'number' ? e.pageY : e.touches[0].pageY;
  var left = x - (container.getBoundingClientRect().left + window.pageXOffset);
  var top = y - (container.getBoundingClientRect().top + window.pageYOffset);

if (props.direction === 'vertical') {
    var a = void 0;
    if (top < 0) {
      a = 0;
    } else if (top > containerHeight) {
      a = 1;
    } else {
      a = Math.round(top * 100 / containerHeight) / 100;
    }

if (props.hsl.a !== a) {
      return {
        h: props.hsl.h,
        s: props.hsl.s,
        l: props.hsl.l,
        a: a,
        source: 'rgb'
      };
    }
  } else {
    var _a = void 0;
    if (left < 0) {
      _a = 0;
    } else if (left > containerWidth) {
      _a = 1;
    } else {
      _a = Math.round(left * 100 / containerWidth) / 100;
    }

if (props.a !== _a) {
      return {
        h: props.hsl.h,
        s: props.hsl.s,
        l: props.hsl.l,
        a: _a,
        source: 'rgb'
      };
    }
  }
  return null;
};

/***/ }),
/* 1210 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var checkboardCache = {};

var get = exports.get = function get(c1, c2, size, serverCanvas) {
  var key = c1 + '-' + c2 + '-' + size + (serverCanvas ? '-server' : '');
  var checkboard = render(c1, c2, size, serverCanvas);

if (checkboardCache[key]) {
    return checkboardCache[key];
  }
  checkboardCache[key] = checkboard;
  return checkboard;
};

/***/ }),
/* 1211 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

if (props.direction === 'vertical') {
    var h = void 0;
    if (top < 0) {
      h = 359;
    } else if (top > containerHeight) {
      h = 0;
    } else {
      var percent = -(top * 100 / containerHeight) + 100;
      h = 360 * percent / 100;
    }

if (props.hsl.h !== h) {
      return {
        h: h,
        s: props.hsl.s,
        l: props.hsl.l,
        a: props.hsl.a,
        source: 'rgb'
      };
    }
  } else {
    var _h = void 0;
    if (left < 0) {
      _h = 0;
    } else if (left > containerWidth) {
      _h = 359;
    } else {
      var _percent = left * 100 / containerWidth;
      _h = 360 * _percent / 100;
    }

if (props.hsl.h !== _h) {
      return {
        h: _h,
        s: props.hsl.s,
        l: props.hsl.l,
        a: props.hsl.a,
        source: 'rgb'
      };
    }
  }
  return null;
};

/***/ }),
/* 1212 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.handleFocus = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var handleFocus = exports.handleFocus = function handleFocus(Component) {
  var Span = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'span';
  return function (_React$Component) {
    _inherits(Focus, _React$Component);

function Focus() {
      var _ref;

var _temp, _this, _ret;

_classCallCheck(this, Focus);

for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Focus.__proto__ || Object.getPrototypeOf(Focus)).call.apply(_ref, [this].concat(args))), _this), _this.state = { focus: false }, _this.handleFocus = function () {
        return _this.setState({ focus: true });
      }, _this.handleBlur = function () {
        return _this.setState({ focus: false });
      }, _temp), _possibleConstructorReturn(_this, _ret);
    }

_createClass(Focus, [{
      key: 'render',
      value: function render() {
        return _react2.default.createElement(
          Span,
          { onFocus: this.handleFocus, onBlur: this.handleBlur },
          _react2.default.createElement(Component, _extends({}, this.props, this.state))
        );
      }
    }]);

return Focus;
  }(_react2.default.Component);
};

/***/ }),
/* 1213 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var calculateChange = exports.calculateChange = function calculateChange(e, skip, props, container) {
  e.preventDefault();

var _container$getBoundin = container.getBoundingClientRect(),
      containerWidth = _container$getBoundin.width,
      containerHeight = _container$getBoundin.height;

var x = typeof e.pageX === 'number' ? e.pageX : e.touches[0].pageX;
  var y = typeof e.pageY === 'number' ? e.pageY : e.touches[0].pageY;
  var left = x - (container.getBoundingClientRect().left + window.pageXOffset);
  var top = y - (container.getBoundingClientRect().top + window.pageYOffset);

if (left < 0) {
    left = 0;
  } else if (left > containerWidth) {
    left = containerWidth;
  } else if (top < 0) {
    top = 0;
  } else if (top > containerHeight) {
    top = containerHeight;
  }

var saturation = left * 100 / containerWidth;
  var bright = -(top * 100 / containerHeight) + 100;

return {
    h: props.hsl.h,
    s: saturation,
    v: bright,
    a: props.hsl.a,
    source: 'rgb'
  };
};

/***/ }),
/* 1214 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CustomPicker = exports.TwitterPicker = exports.SwatchesPicker = exports.SliderPicker = exports.SketchPicker = exports.PhotoshopPicker = exports.MaterialPicker = exports.HuePicker = exports.GithubPicker = exports.CompactPicker = exports.ChromePicker = exports.default = exports.CirclePicker = exports.BlockPicker = exports.AlphaPicker = undefined;

var _Alpha = __webpack_require__(1168);

Object.defineProperty(exports, 'AlphaPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Alpha).default;
  }
});

var _Block = __webpack_require__(1170);

Object.defineProperty(exports, 'BlockPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Block).default;
  }
});

var _Circle = __webpack_require__(1176);

Object.defineProperty(exports, 'CirclePicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Circle).default;
  }
});

var _Chrome = __webpack_require__(1172);

Object.defineProperty(exports, 'ChromePicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Chrome).default;
  }
});

var _Compact = __webpack_require__(1184);

Object.defineProperty(exports, 'CompactPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Compact).default;
  }
});

var _Github = __webpack_require__(1187);

Object.defineProperty(exports, 'GithubPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Github).default;
  }
});

var _Hue = __webpack_require__(1189);

Object.defineProperty(exports, 'HuePicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Hue).default;
  }
});

var _Material = __webpack_require__(1191);

Object.defineProperty(exports, 'MaterialPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Material).default;
  }
});

var _Photoshop = __webpack_require__(1192);

Object.defineProperty(exports, 'PhotoshopPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Photoshop).default;
  }
});

var _Sketch = __webpack_require__(1198);

Object.defineProperty(exports, 'SketchPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Sketch).default;
  }
});

var _Slider = __webpack_require__(1201);

Object.defineProperty(exports, 'SliderPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Slider).default;
  }
});

var _Swatches = __webpack_require__(1205);

Object.defineProperty(exports, 'SwatchesPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Swatches).default;
  }
});

var _Twitter = __webpack_require__(1208);

Object.defineProperty(exports, 'TwitterPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Twitter).default;
  }
});

var _ColorWrap = __webpack_require__(484);

Object.defineProperty(exports, 'CustomPicker', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_ColorWrap).default;
  }
});

var _Chrome2 = _interopRequireDefault(_Chrome);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _Chrome2.default;

/***/ }),
/* 1215 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. 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

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */

function __rest(s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
            t[p[i]] = s[p[i]];
    return t;
}

var uid = (function () {
    return Math.random()
        .toString(36)
        .substring(2);
});

var FacebookStyle = (function (props) { return (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])(ContentLoader, __assign({}, props),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "70", y: "15", rx: "4", ry: "4", width: "117", height: "6.4" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "70", y: "35", rx: "3", ry: "3", width: "85", height: "6.4" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "0", y: "80", rx: "3", ry: "3", width: "350", height: "6.4" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "0", y: "100", rx: "3", ry: "3", width: "380", height: "6.4" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "0", y: "120", rx: "3", ry: "3", width: "201", height: "6.4" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("circle", { cx: "30", cy: "30", r: "30" }))); });

var InstagramStyle = (function (props) { return (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])(ContentLoader, __assign({}, props, { height: 480 }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("circle", { cx: "30", cy: "30", r: "30" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "75", y: "13", rx: "4", ry: "4", width: "100", height: "13" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "75", y: "37", rx: "4", ry: "4", width: "50", height: "8" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "0", y: "70", rx: "5", ry: "5", width: "400", height: "400" }))); });

var CodeStyle = (function (props) { return (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])(ContentLoader, __assign({}, props),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "0", y: "0", rx: "3", ry: "3", width: "70", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "80", y: "0", rx: "3", ry: "3", width: "100", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "190", y: "0", rx: "3", ry: "3", width: "10", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "15", y: "20", rx: "3", ry: "3", width: "130", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "155", y: "20", rx: "3", ry: "3", width: "130", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "15", y: "40", rx: "3", ry: "3", width: "90", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "115", y: "40", rx: "3", ry: "3", width: "60", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "185", y: "40", rx: "3", ry: "3", width: "60", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "0", y: "60", rx: "3", ry: "3", width: "30", height: "10" }))); });

var ListStyle = (function (props) { return (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])(ContentLoader, __assign({}, props),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "0", y: "0", rx: "3", ry: "3", width: "250", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "20", y: "20", rx: "3", ry: "3", width: "220", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "20", y: "40", rx: "3", ry: "3", width: "170", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "0", y: "60", rx: "3", ry: "3", width: "250", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "20", y: "80", rx: "3", ry: "3", width: "200", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "20", y: "100", rx: "3", ry: "3", width: "80", height: "10" }))); });

var BulletListStyle = (function (props) { return (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])(ContentLoader, __assign({}, props),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("circle", { cx: "10", cy: "20", r: "8" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "25", y: "15", rx: "5", ry: "5", width: "220", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("circle", { cx: "10", cy: "50", r: "8" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "25", y: "45", rx: "5", ry: "5", width: "220", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("circle", { cx: "10", cy: "80", r: "8" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "25", y: "75", rx: "5", ry: "5", width: "220", height: "10" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("circle", { cx: "10", cy: "110", r: "8" }),
    __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_react__["createElement"])("rect", { x: "25", y: "105", rx: "5", ry: "5", width: "220", height: "10" }))); });

/* harmony default export */ __webpack_exports__["default"] = (ContentLoader);

/***/ }),
/* 1216 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _lodashUnion = __webpack_require__(1095);

var _lodashUnion2 = _interopRequireDefault(_lodashUnion);

var _lodashWithout = __webpack_require__(457);

var _lodashWithout2 = _interopRequireDefault(_lodashWithout);

var EnterLeaveCounter = (function () {
  function EnterLeaveCounter() {
    _classCallCheck(this, EnterLeaveCounter);

this.entered = [];
  }

EnterLeaveCounter.prototype.enter = function enter(enteringNode) {
    var previousLength = this.entered.length;

this.entered = _lodashUnion2['default'](this.entered.filter(function (node) {
      return document.documentElement.contains(node) && (!node.contains || node.contains(enteringNode));
    }), [enteringNode]);

return previousLength === 0 && this.entered.length > 0;
  };

EnterLeaveCounter.prototype.leave = function leave(leavingNode) {
    var previousLength = this.entered.length;

this.entered = _lodashWithout2['default'](this.entered.filter(function (node) {
      return document.documentElement.contains(node);
    }), leavingNode);

return previousLength > 0 && this.entered.length === 0;
  };

EnterLeaveCounter.prototype.reset = function reset() {
    this.entered = [];
  };

return EnterLeaveCounter;
})();

exports['default'] = EnterLeaveCounter;
module.exports = exports['default'];

/***/ }),
/* 1217 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _lodashDefaults = __webpack_require__(1079);

var _lodashDefaults2 = _interopRequireDefault(_lodashDefaults);

var _shallowEqual = __webpack_require__(1222);

var _shallowEqual2 = _interopRequireDefault(_shallowEqual);

var _EnterLeaveCounter = __webpack_require__(1216);

var _EnterLeaveCounter2 = _interopRequireDefault(_EnterLeaveCounter);

var _BrowserDetector = __webpack_require__(485);

var _OffsetUtils = __webpack_require__(1220);

var _NativeDragSources = __webpack_require__(1219);

var _NativeTypes = __webpack_require__(303);

var NativeTypes = _interopRequireWildcard(_NativeTypes);

var HTML5Backend = (function () {
  function HTML5Backend(manager) {
    _classCallCheck(this, HTML5Backend);

this.actions = manager.getActions();
    this.monitor = manager.getMonitor();
    this.registry = manager.getRegistry();

this.sourcePreviewNodes = {};
    this.sourcePreviewNodeOptions = {};
    this.sourceNodes = {};
    this.sourceNodeOptions = {};
    this.enterLeaveCounter = new _EnterLeaveCounter2['default']();

this.getSourceClientOffset = this.getSourceClientOffset.bind(this);
    this.handleTopDragStart = this.handleTopDragStart.bind(this);
    this.handleTopDragStartCapture = this.handleTopDragStartCapture.bind(this);
    this.handleTopDragEndCapture = this.handleTopDragEndCapture.bind(this);
    this.handleTopDragEnter = this.handleTopDragEnter.bind(this);
    this.handleTopDragEnterCapture = this.handleTopDragEnterCapture.bind(this);
    this.handleTopDragLeaveCapture = this.handleTopDragLeaveCapture.bind(this);
    this.handleTopDragOver = this.handleTopDragOver.bind(this);
    this.handleTopDragOverCapture = this.handleTopDragOverCapture.bind(this);
    this.handleTopDrop = this.handleTopDrop.bind(this);
    this.handleTopDropCapture = this.handleTopDropCapture.bind(this);
    this.handleSelectStart = this.handleSelectStart.bind(this);
    this.endDragIfSourceWasRemovedFromDOM = this.endDragIfSourceWasRemovedFromDOM.bind(this);
    this.endDragNativeItem = this.endDragNativeItem.bind(this);
  }

HTML5Backend.prototype.setup = function setup() {
    if (typeof window === 'undefined') {
      return;
    }

if (this.constructor.isSetUp) {
      throw new Error('Cannot have two HTML5 backends at the same time.');
    }
    this.constructor.isSetUp = true;
    this.addEventListeners(window);
  };

HTML5Backend.prototype.teardown = function teardown() {
    if (typeof window === 'undefined') {
      return;
    }

this.constructor.isSetUp = false;
    this.removeEventListeners(window);
    this.clearCurrentDragSourceNode();
  };

HTML5Backend.prototype.addEventListeners = function addEventListeners(target) {
    target.addEventListener('dragstart', this.handleTopDragStart);
    target.addEventListener('dragstart', this.handleTopDragStartCapture, true);
    target.addEventListener('dragend', this.handleTopDragEndCapture, true);
    target.addEventListener('dragenter', this.handleTopDragEnter);
    target.addEventListener('dragenter', this.handleTopDragEnterCapture, true);
    target.addEventListener('dragleave', this.handleTopDragLeaveCapture, true);
    target.addEventListener('dragover', this.handleTopDragOver);
    target.addEventListener('dragover', this.handleTopDragOverCapture, true);
    target.addEventListener('drop', this.handleTopDrop);
    target.addEventListener('drop', this.handleTopDropCapture, true);
  };

HTML5Backend.prototype.removeEventListeners = function removeEventListeners(target) {
    target.removeEventListener('dragstart', this.handleTopDragStart);
    target.removeEventListener('dragstart', this.handleTopDragStartCapture, true);
    target.removeEventListener('dragend', this.handleTopDragEndCapture, true);
    target.removeEventListener('dragenter', this.handleTopDragEnter);
    target.removeEventListener('dragenter', this.handleTopDragEnterCapture, true);
    target.removeEventListener('dragleave', this.handleTopDragLeaveCapture, true);
    target.removeEventListener('dragover', this.handleTopDragOver);
    target.removeEventListener('dragover', this.handleTopDragOverCapture, true);
    target.removeEventListener('drop', this.handleTopDrop);
    target.removeEventListener('drop', this.handleTopDropCapture, true);
  };

HTML5Backend.prototype.connectDragPreview = function connectDragPreview(sourceId, node, options) {
    var _this = this;

this.sourcePreviewNodeOptions[sourceId] = options;
    this.sourcePreviewNodes[sourceId] = node;

return function () {
      delete _this.sourcePreviewNodes[sourceId];
      delete _this.sourcePreviewNodeOptions[sourceId];
    };
  };

HTML5Backend.prototype.connectDragSource = function connectDragSource(sourceId, node, options) {
    var _this2 = this;

this.sourceNodes[sourceId] = node;
    this.sourceNodeOptions[sourceId] = options;

var handleDragStart = function handleDragStart(e) {
      return _this2.handleDragStart(e, sourceId);
    };
    var handleSelectStart = function handleSelectStart(e) {
      return _this2.handleSelectStart(e, sourceId);
    };

node.setAttribute('draggable', true);
    node.addEventListener('dragstart', handleDragStart);
    node.addEventListener('selectstart', handleSelectStart);

return function () {
      delete _this2.sourceNodes[sourceId];
      delete _this2.sourceNodeOptions[sourceId];

node.removeEventListener('dragstart', handleDragStart);
      node.removeEventListener('selectstart', handleSelectStart);
      node.setAttribute('draggable', false);
    };
  };

HTML5Backend.prototype.connectDropTarget = function connectDropTarget(targetId, node) {
    var _this3 = this;

node.addEventListener('dragenter', handleDragEnter);
    node.addEventListener('dragover', handleDragOver);
    node.addEventListener('drop', handleDrop);

return function () {
      node.removeEventListener('dragenter', handleDragEnter);
      node.removeEventListener('dragover', handleDragOver);
      node.removeEventListener('drop', handleDrop);
    };
  };

HTML5Backend.prototype.getCurrentSourceNodeOptions = function getCurrentSourceNodeOptions() {
    var sourceId = this.monitor.getSourceId();
    var sourceNodeOptions = this.sourceNodeOptions[sourceId];

return _lodashDefaults2['default'](sourceNodeOptions || {}, {
      dropEffect: 'move'
    });
  };

HTML5Backend.prototype.getCurrentDropEffect = function getCurrentDropEffect() {
    if (this.isDraggingNativeItem()) {
      // It makes more sense to default to 'copy' for native resources
      return 'copy';
    }

return this.getCurrentSourceNodeOptions().dropEffect;
  };

HTML5Backend.prototype.getCurrentSourcePreviewNodeOptions = function getCurrentSourcePreviewNodeOptions() {
    var sourceId = this.monitor.getSourceId();
    var sourcePreviewNodeOptions = this.sourcePreviewNodeOptions[sourceId];

return _lodashDefaults2['default'](sourcePreviewNodeOptions || {}, {
      anchorX: 0.5,
      anchorY: 0.5,
      captureDraggingState: false
    });
  };

HTML5Backend.prototype.getSourceClientOffset = function getSourceClientOffset(sourceId) {
    return _OffsetUtils.getNodeClientOffset(this.sourceNodes[sourceId]);
  };

HTML5Backend.prototype.isDraggingNativeItem = function isDraggingNativeItem() {
    var itemType = this.monitor.getItemType();
    return Object.keys(NativeTypes).some(function (key) {
      return NativeTypes[key] === itemType;
    });
  };

HTML5Backend.prototype.beginDragNativeItem = function beginDragNativeItem(type) {
    this.clearCurrentDragSourceNode();

var SourceType = _NativeDragSources.createNativeDragSource(type);
    this.currentNativeSource = new SourceType();
    this.currentNativeHandle = this.registry.addSource(type, this.currentNativeSource);
    this.actions.beginDrag([this.currentNativeHandle]);

// On Firefox, if mousemove fires, the drag is over but browser failed to tell us.
    // This is not true for other browsers.
    if (_BrowserDetector.isFirefox()) {
      window.addEventListener('mousemove', this.endDragNativeItem, true);
    }
  };

HTML5Backend.prototype.endDragNativeItem = function endDragNativeItem() {
    if (!this.isDraggingNativeItem()) {
      return;
    }

if (_BrowserDetector.isFirefox()) {
      window.removeEventListener('mousemove', this.endDragNativeItem, true);
    }

this.actions.endDrag();
    this.registry.removeSource(this.currentNativeHandle);
    this.currentNativeHandle = null;
    this.currentNativeSource = null;
  };

HTML5Backend.prototype.endDragIfSourceWasRemovedFromDOM = function endDragIfSourceWasRemovedFromDOM() {
    var node = this.currentDragSourceNode;
    if (document.body.contains(node)) {
      return;
    }

if (this.clearCurrentDragSourceNode()) {
      this.actions.endDrag();
    }
  };

HTML5Backend.prototype.setCurrentDragSourceNode = function setCurrentDragSourceNode(node) {
    this.clearCurrentDragSourceNode();
    this.currentDragSourceNode = node;
    this.currentDragSourceNodeOffset = _OffsetUtils.getNodeClientOffset(node);
    this.currentDragSourceNodeOffsetChanged = false;

// Receiving a mouse event in the middle of a dragging operation
    // means it has ended and the drag source node disappeared from DOM,
    // so the browser didn't dispatch the dragend event.
    window.addEventListener('mousemove', this.endDragIfSourceWasRemovedFromDOM, true);
  };

HTML5Backend.prototype.clearCurrentDragSourceNode = function clearCurrentDragSourceNode() {
    if (this.currentDragSourceNode) {
      this.currentDragSourceNode = null;
      this.currentDragSourceNodeOffset = null;
      this.currentDragSourceNodeOffsetChanged = false;
      window.removeEventListener('mousemove', this.endDragIfSourceWasRemovedFromDOM, true);
      return true;
    }

return false;
  };

HTML5Backend.prototype.checkIfCurrentDragSourceRectChanged = function checkIfCurrentDragSourceRectChanged() {
    var node = this.currentDragSourceNode;
    if (!node) {
      return false;
    }

if (this.currentDragSourceNodeOffsetChanged) {
      return true;
    }

this.currentDragSourceNodeOffsetChanged = !_shallowEqual2['default'](_OffsetUtils.getNodeClientOffset(node), this.currentDragSourceNodeOffset);

return this.currentDragSourceNodeOffsetChanged;
  };

HTML5Backend.prototype.handleTopDragStartCapture = function handleTopDragStartCapture() {
    this.clearCurrentDragSourceNode();
    this.dragStartSourceIds = [];
  };

HTML5Backend.prototype.handleDragStart = function handleDragStart(e, sourceId) {
    this.dragStartSourceIds.unshift(sourceId);
  };

HTML5Backend.prototype.handleTopDragStart = function handleTopDragStart(e) {
    var _this4 = this;

var dragStartSourceIds = this.dragStartSourceIds;

this.dragStartSourceIds = null;

var clientOffset = _OffsetUtils.getEventClientOffset(e);

// Don't publish the source just yet (see why below)
    this.actions.beginDrag(dragStartSourceIds, {
      publishSource: false,
      getSourceClientOffset: this.getSourceClientOffset,
      clientOffset: clientOffset
    });

var dataTransfer = e.dataTransfer;

var nativeType = _NativeDragSources.matchNativeItemType(dataTransfer);

if (this.monitor.isDragging()) {
      if (typeof dataTransfer.setDragImage === 'function') {
        // Use custom drag image if user specifies it.
        // If child drag source refuses drag but parent agrees,
        // use parent's node as drag image. Neither works in IE though.
        var sourceId = this.monitor.getSourceId();
        var sourceNode = this.sourceNodes[sourceId];
        var dragPreview = this.sourcePreviewNodes[sourceId] || sourceNode;

var _getCurrentSourcePreviewNodeOptions = this.getCurrentSourcePreviewNodeOptions();

var anchorX = _getCurrentSourcePreviewNodeOptions.anchorX;
        var anchorY = _getCurrentSourcePreviewNodeOptions.anchorY;

var anchorPoint = { anchorX: anchorX, anchorY: anchorY };
        var dragPreviewOffset = _OffsetUtils.getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint);
        dataTransfer.setDragImage(dragPreview, dragPreviewOffset.x, dragPreviewOffset.y);
      }

try {
        // Firefox won't drag without setting data
        dataTransfer.setData('application/json', {});
      } catch (err) {}
      // IE doesn't support MIME types in setData

// Store drag source node so we can check whether
      // it is removed from DOM and trigger endDrag manually.
      this.setCurrentDragSourceNode(e.target);

// Now we are ready to publish the drag source.. or are we not?

var _getCurrentSourcePreviewNodeOptions2 = this.getCurrentSourcePreviewNodeOptions();

var captureDraggingState = _getCurrentSourcePreviewNodeOptions2.captureDraggingState;

if (!captureDraggingState) {
        // Usually we want to publish it in the next tick so that browser
        // is able to screenshot the current (not yet dragging) state.
        //
        // It also neatly avoids a situation where render() returns null
        // in the same tick for the source element, and browser freaks out.
        setTimeout(function () {
          return _this4.actions.publishDragSource();
        });
      } else {
        // In some cases the user may want to override this behavior, e.g.
        // to work around IE not supporting custom drag previews.
        //
        // When using a custom drag layer, the only way to prevent
        // the default drag preview from drawing in IE is to screenshot
        // the dragging state in which the node itself has zero opacity
        // and height. In this case, though, returning null from render()
        // will abruptly end the dragging, which is not obvious.
        //
        // This is the reason such behavior is strictly opt-in.
        this.actions.publishDragSource();
      }
    } else if (nativeType) {
      // A native item (such as URL) dragged from inside the document
      this.beginDragNativeItem(nativeType);
    } else if (!dataTransfer.types && (!e.target.hasAttribute || !e.target.hasAttribute('draggable'))) {
      // Looks like a Safari bug: dataTransfer.types is null, but there was no draggable.
      // Just let it drag. It's a native type (URL or text) and will be picked up in dragenter handler.
      return;
    } else {
      // If by this time no drag source reacted, tell browser not to drag.
      e.preventDefault();
    }
  };

HTML5Backend.prototype.handleTopDragEndCapture = function handleTopDragEndCapture() {
    if (this.clearCurrentDragSourceNode()) {
      // Firefox can dispatch this event in an infinite loop
      // if dragend handler does something like showing an alert.
      // Only proceed if we have not handled it already.
      this.actions.endDrag();
    }
  };

HTML5Backend.prototype.handleTopDragEnterCapture = function handleTopDragEnterCapture(e) {
    this.dragEnterTargetIds = [];

var isFirstEnter = this.enterLeaveCounter.enter(e.target);
    if (!isFirstEnter || this.monitor.isDragging()) {
      return;
    }

var dataTransfer = e.dataTransfer;

var nativeType = _NativeDragSources.matchNativeItemType(dataTransfer);

if (nativeType) {
      // A native item (such as file or URL) dragged from outside the document
      this.beginDragNativeItem(nativeType);
    }
  };

HTML5Backend.prototype.handleDragEnter = function handleDragEnter(e, targetId) {
    this.dragEnterTargetIds.unshift(targetId);
  };

HTML5Backend.prototype.handleTopDragEnter = function handleTopDragEnter(e) {
    var _this5 = this;

var dragEnterTargetIds = this.dragEnterTargetIds;

this.dragEnterTargetIds = [];

if (!this.monitor.isDragging()) {
      // This is probably a native item type we don't understand.
      return;
    }

if (!_BrowserDetector.isFirefox()) {
      // Don't emit hover in `dragenter` on Firefox due to an edge case.
      // If the target changes position as the result of `dragenter`, Firefox
      // will still happily dispatch `dragover` despite target being no longer
      // there. The easy solution is to only fire `hover` in `dragover` on FF.
      this.actions.hover(dragEnterTargetIds, {
        clientOffset: _OffsetUtils.getEventClientOffset(e)
      });
    }

var canDrop = dragEnterTargetIds.some(function (targetId) {
      return _this5.monitor.canDropOnTarget(targetId);
    });

if (canDrop) {
      // IE requires this to fire dragover events
      e.preventDefault();
      e.dataTransfer.dropEffect = this.getCurrentDropEffect();
    }
  };

HTML5Backend.prototype.handleTopDragOverCapture = function handleTopDragOverCapture() {
    this.dragOverTargetIds = [];
  };

HTML5Backend.prototype.handleDragOver = function handleDragOver(e, targetId) {
    this.dragOverTargetIds.unshift(targetId);
  };

HTML5Backend.prototype.handleTopDragOver = function handleTopDragOver(e) {
    var _this6 = this;

var dragOverTargetIds = this.dragOverTargetIds;

this.dragOverTargetIds = [];

if (!this.monitor.isDragging()) {
      // This is probably a native item type we don't understand.
      // Prevent default "drop and blow away the whole document" action.
      e.preventDefault();
      e.dataTransfer.dropEffect = 'none';
      return;
    }

this.actions.hover(dragOverTargetIds, {
      clientOffset: _OffsetUtils.getEventClientOffset(e)
    });

var canDrop = dragOverTargetIds.some(function (targetId) {
      return _this6.monitor.canDropOnTarget(targetId);
    });

if (canDrop) {
      // Show user-specified drop effect.
      e.preventDefault();
      e.dataTransfer.dropEffect = this.getCurrentDropEffect();
    } else if (this.isDraggingNativeItem()) {
      // Don't show a nice cursor but still prevent default
      // "drop and blow away the whole document" action.
      e.preventDefault();
      e.dataTransfer.dropEffect = 'none';
    } else if (this.checkIfCurrentDragSourceRectChanged()) {
      // Prevent animating to incorrect position.
      // Drop effect must be other than 'none' to prevent animation.
      e.preventDefault();
      e.dataTransfer.dropEffect = 'move';
    }
  };

HTML5Backend.prototype.handleTopDragLeaveCapture = function handleTopDragLeaveCapture(e) {
    if (this.isDraggingNativeItem()) {
      e.preventDefault();
    }

var isLastLeave = this.enterLeaveCounter.leave(e.target);
    if (!isLastLeave) {
      return;
    }

if (this.isDraggingNativeItem()) {
      this.endDragNativeItem();
    }
  };

HTML5Backend.prototype.handleTopDropCapture = function handleTopDropCapture(e) {
    this.dropTargetIds = [];
    e.preventDefault();

if (this.isDraggingNativeItem()) {
      this.currentNativeSource.mutateItemByReadingDataTransfer(e.dataTransfer);
    }

this.enterLeaveCounter.reset();
  };

HTML5Backend.prototype.handleDrop = function handleDrop(e, targetId) {
    this.dropTargetIds.unshift(targetId);
  };

HTML5Backend.prototype.handleTopDrop = function handleTopDrop(e) {
    var dropTargetIds = this.dropTargetIds;

this.dropTargetIds = [];

this.actions.hover(dropTargetIds, {
      clientOffset: _OffsetUtils.getEventClientOffset(e)
    });
    this.actions.drop();

if (this.isDraggingNativeItem()) {
      this.endDragNativeItem();
    } else {
      this.endDragIfSourceWasRemovedFromDOM();
    }
  };

HTML5Backend.prototype.handleSelectStart = function handleSelectStart(e) {
    var target = e.target;

// Only IE requires us to explicitly say
    // we want drag drop operation to start
    if (typeof target.dragDrop !== 'function') {
      return;
    }

// Inputs and textareas should be selectable
    if (target.tagName === 'INPUT' || target.tagName === 'SELECT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
      return;
    }

// For other targets, ask IE
    // to enable drag and drop
    e.preventDefault();
    target.dragDrop();
  };

return HTML5Backend;
})();

exports['default'] = HTML5Backend;
module.exports = exports['default'];

/***/ }),
/* 1218 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var MonotonicInterpolant = (function () {
  function MonotonicInterpolant(xs, ys) {
    _classCallCheck(this, MonotonicInterpolant);

var length = xs.length;

// Rearrange xs and ys so that xs is sorted
    var indexes = [];
    for (var i = 0; i < length; i++) {
      indexes.push(i);
    }
    indexes.sort(function (a, b) {
      return xs[a] < xs[b] ? -1 : 1;
    });

// Get consecutive differences and slopes
    var dys = [];
    var dxs = [];
    var ms = [];
    var dx = undefined;
    var dy = undefined;
    for (var i = 0; i < length - 1; i++) {
      dx = xs[i + 1] - xs[i];
      dy = ys[i + 1] - ys[i];
      dxs.push(dx);
      dys.push(dy);
      ms.push(dy / dx);
    }

// Get degree-1 coefficients
    var c1s = [ms[0]];
    for (var i = 0; i < dxs.length - 1; i++) {
      var _m = ms[i];
      var mNext = ms[i + 1];
      if (_m * mNext <= 0) {
        c1s.push(0);
      } else {
        dx = dxs[i];
        var dxNext = dxs[i + 1];
        var common = dx + dxNext;
        c1s.push(3 * common / ((common + dxNext) / _m + (common + dx) / mNext));
      }
    }
    c1s.push(ms[ms.length - 1]);

// Get degree-2 and degree-3 coefficients
    var c2s = [];
    var c3s = [];
    var m = undefined;
    for (var i = 0; i < c1s.length - 1; i++) {
      m = ms[i];
      var c1 = c1s[i];
      var invDx = 1 / dxs[i];
      var common = c1 + c1s[i + 1] - m - m;
      c2s.push((m - c1 - common) * invDx);
      c3s.push(common * invDx * invDx);
    }

this.xs = xs;
    this.ys = ys;
    this.c1s = c1s;
    this.c2s = c2s;
    this.c3s = c3s;
  }

MonotonicInterpolant.prototype.interpolate = function interpolate(x) {
    var xs = this.xs;
    var ys = this.ys;
    var c1s = this.c1s;
    var c2s = this.c2s;
    var c3s = this.c3s;

// The rightmost point in the dataset should give an exact result
    var i = xs.length - 1;
    if (x === xs[i]) {
      return ys[i];
    }

// Search for the interval x is in, returning the corresponding y if x is one of the original xs
    var low = 0;
    var high = c3s.length - 1;
    var mid = undefined;
    while (low <= high) {
      mid = Math.floor(0.5 * (low + high));
      var xHere = xs[mid];
      if (xHere < x) {
        low = mid + 1;
      } else if (xHere > x) {
        high = mid - 1;
      } else {
        return ys[mid];
      }
    }
    i = Math.max(0, high);

// Interpolate
    var diff = x - xs[i];
    var diffSq = diff * diff;
    return ys[i] + c1s[i] * diff + c2s[i] * diffSq + c3s[i] * diff * diffSq;
  };

return MonotonicInterpolant;
})();

exports["default"] = MonotonicInterpolant;
module.exports = exports["default"];

/***/ }),
/* 1219 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _nativeTypesConfig;

exports.createNativeDragSource = createNativeDragSource;
exports.matchNativeItemType = matchNativeItemType;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _NativeTypes = __webpack_require__(303);

var NativeTypes = _interopRequireWildcard(_NativeTypes);

function getDataFromDataTransfer(dataTransfer, typesToTry, defaultValue) {
  var result = typesToTry.reduce(function (resultSoFar, typeToTry) {
    return resultSoFar || dataTransfer.getData(typeToTry);
  }, null);

return result != null ? // eslint-disable-line eqeqeq
  result : defaultValue;
}

function createNativeDragSource(type) {
  var _nativeTypesConfig$type = nativeTypesConfig[type];
  var exposeProperty = _nativeTypesConfig$type.exposeProperty;
  var matchesTypes = _nativeTypesConfig$type.matchesTypes;
  var getData = _nativeTypesConfig$type.getData;

return (function () {
    function NativeDragSource() {
      _classCallCheck(this, NativeDragSource);

this.item = Object.defineProperties({}, _defineProperty({}, exposeProperty, {
        get: function get() {
          console.warn( // eslint-disable-line no-console
          'Browser doesn\'t allow reading "' + exposeProperty + '" until the drop event.');
          return null;
        },
        configurable: true,
        enumerable: true
      }));
    }

NativeDragSource.prototype.mutateItemByReadingDataTransfer = function mutateItemByReadingDataTransfer(dataTransfer) {
      delete this.item[exposeProperty];
      this.item[exposeProperty] = getData(dataTransfer, matchesTypes);
    };

NativeDragSource.prototype.canDrag = function canDrag() {
      return true;
    };

NativeDragSource.prototype.beginDrag = function beginDrag() {
      return this.item;
    };

NativeDragSource.prototype.isDragging = function isDragging(monitor, handle) {
      return handle === monitor.getSourceId();
    };

NativeDragSource.prototype.endDrag = function endDrag() {};

return NativeDragSource;
  })();
}

function matchNativeItemType(dataTransfer) {
  var dataTransferTypes = Array.prototype.slice.call(dataTransfer.types || []);

return Object.keys(nativeTypesConfig).filter(function (nativeItemType) {
    var matchesTypes = nativeTypesConfig[nativeItemType].matchesTypes;

return matchesTypes.some(function (t) {
      return dataTransferTypes.indexOf(t) > -1;
    });
  })[0] || null;
}

/***/ }),
/* 1220 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.getNodeClientOffset = getNodeClientOffset;
exports.getEventClientOffset = getEventClientOffset;
exports.getDragPreviewOffset = getDragPreviewOffset;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _BrowserDetector = __webpack_require__(485);

var _MonotonicInterpolant = __webpack_require__(1218);

var _MonotonicInterpolant2 = _interopRequireDefault(_MonotonicInterpolant);

var ELEMENT_NODE = 1;

function getNodeClientOffset(node) {
  var el = node.nodeType === ELEMENT_NODE ? node : node.parentElement;

if (!el) {
    return null;
  }

var _el$getBoundingClientRect = el.getBoundingClientRect();

var top = _el$getBoundingClientRect.top;
  var left = _el$getBoundingClientRect.left;

return { x: left, y: top };
}

function getEventClientOffset(e) {
  return {
    x: e.clientX,
    y: e.clientY
  };
}

function getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint) {
  // The browsers will use the image intrinsic size under different conditions.
  // Firefox only cares if it's an image, but WebKit also wants it to be detached.
  var isImage = dragPreview.nodeName === 'IMG' && (_BrowserDetector.isFirefox() || !document.documentElement.contains(dragPreview));
  var dragPreviewNode = isImage ? sourceNode : dragPreview;

var dragPreviewNodeOffsetFromClient = getNodeClientOffset(dragPreviewNode);
  var offsetFromDragPreview = {
    x: clientOffset.x - dragPreviewNodeOffsetFromClient.x,
    y: clientOffset.y - dragPreviewNodeOffsetFromClient.y
  };

var sourceWidth = sourceNode.offsetWidth;
  var sourceHeight = sourceNode.offsetHeight;
  var anchorX = anchorPoint.anchorX;
  var anchorY = anchorPoint.anchorY;

var dragPreviewWidth = isImage ? dragPreview.width : sourceWidth;
  var dragPreviewHeight = isImage ? dragPreview.height : sourceHeight;

// Work around @2x coordinate discrepancies in browsers
  if (_BrowserDetector.isSafari() && isImage) {
    dragPreviewHeight /= window.devicePixelRatio;
    dragPreviewWidth /= window.devicePixelRatio;
  } else if (_BrowserDetector.isFirefox() && !isImage) {
    dragPreviewHeight *= window.devicePixelRatio;
    dragPreviewWidth *= window.devicePixelRatio;
  }

// Interpolate coordinates depending on anchor point
  // If you know a simpler way to do this, let me know
  var interpolantX = new _MonotonicInterpolant2['default']([0, 0.5, 1], [
  // Dock to the left
  offsetFromDragPreview.x,
  // Align at the center
  offsetFromDragPreview.x / sourceWidth * dragPreviewWidth,
  // Dock to the right
  offsetFromDragPreview.x + dragPreviewWidth - sourceWidth]);
  var interpolantY = new _MonotonicInterpolant2['default']([0, 0.5, 1], [
  // Dock to the top
  offsetFromDragPreview.y,
  // Align at the center
  offsetFromDragPreview.y / sourceHeight * dragPreviewHeight,
  // Dock to the bottom
  offsetFromDragPreview.y + dragPreviewHeight - sourceHeight]);
  var x = interpolantX.interpolate(anchorX);
  var y = interpolantY.interpolate(anchorY);

// Work around Safari 8 positioning bug
  if (_BrowserDetector.isSafari() && isImage) {
    // We'll have to wait for @3x to see if this is entirely correct
    y += (window.devicePixelRatio - 1) * dragPreviewHeight;
  }

return { x: x, y: y };
}

/***/ }),
/* 1221 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = getEmptyImage;
var emptyImage = undefined;

function getEmptyImage() {
  if (!emptyImage) {
    emptyImage = new Image();
    emptyImage.src = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
  }

return emptyImage;
}

module.exports = exports['default'];

/***/ }),
/* 1222 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports["default"] = shallowEqual;

function shallowEqual(objA, objB) {
  if (objA === objB) {
    return true;
  }

var keysA = Object.keys(objA);
  var keysB = Object.keys(objB);

if (keysA.length !== keysB.length) {
    return false;
  }

var valA = objA[keysA[i]];
    var valB = objB[keysA[i]];

if (valA !== valB) {
      return false;
    }
  }

return true;
}

module.exports = exports["default"];

/***/ }),
/* 1223 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _slice = Array.prototype.slice;

exports['default'] = DragDropContext;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _dndCore = __webpack_require__(856);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _utilsCheckDecoratorArguments = __webpack_require__(186);

var _utilsCheckDecoratorArguments2 = _interopRequireDefault(_utilsCheckDecoratorArguments);

function DragDropContext(backendOrModule) {
  _utilsCheckDecoratorArguments2['default'].apply(undefined, ['DragDropContext', 'backend'].concat(_slice.call(arguments)));

// Auto-detect ES6 default export for people still using ES5
  var backend = undefined;
  if (typeof backendOrModule === 'object' && typeof backendOrModule['default'] === 'function') {
    backend = backendOrModule['default'];
  } else {
    backend = backendOrModule;
  }

_invariant2['default'](typeof backend === 'function', 'Expected the backend to be a function or an ES6 module exporting a default function. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-drop-context.html');

var childContext = {
    dragDropManager: new _dndCore.DragDropManager(backend)
  };

return function decorateContext(DecoratedComponent) {
    var displayName = DecoratedComponent.displayName || DecoratedComponent.name || 'Component';

return (function (_Component) {
      _inherits(DragDropContextContainer, _Component);

function DragDropContextContainer() {
        _classCallCheck(this, DragDropContextContainer);

_Component.apply(this, arguments);
      }

DragDropContextContainer.prototype.getDecoratedComponentInstance = function getDecoratedComponentInstance() {
        return this.refs.child;
      };

DragDropContextContainer.prototype.getManager = function getManager() {
        return childContext.dragDropManager;
      };

DragDropContextContainer.prototype.getChildContext = function getChildContext() {
        return childContext;
      };

DragDropContextContainer.prototype.render = function render() {
        return _react2['default'].createElement(DecoratedComponent, _extends({}, this.props, {
          ref: 'child' }));
      };

_createClass(DragDropContextContainer, null, [{
        key: 'DecoratedComponent',
        value: DecoratedComponent,
        enumerable: true
      }, {
        key: 'displayName',
        value: 'DragDropContext(' + displayName + ')',
        enumerable: true
      }, {
        key: 'childContextTypes',
        value: {
          dragDropManager: _react.PropTypes.object.isRequired
        },
        enumerable: true
      }]);

return DragDropContextContainer;
    })(_react.Component);
  };
}

module.exports = exports['default'];

/***/ }),
/* 1224 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _slice = Array.prototype.slice;

exports['default'] = DragLayer;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _utilsShallowEqual = __webpack_require__(305);

var _utilsShallowEqual2 = _interopRequireDefault(_utilsShallowEqual);

var _utilsShallowEqualScalar = __webpack_require__(489);

var _utilsShallowEqualScalar2 = _interopRequireDefault(_utilsShallowEqualScalar);

var _lodashIsPlainObject = __webpack_require__(48);

var _lodashIsPlainObject2 = _interopRequireDefault(_lodashIsPlainObject);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _utilsCheckDecoratorArguments = __webpack_require__(186);

var _utilsCheckDecoratorArguments2 = _interopRequireDefault(_utilsCheckDecoratorArguments);

function DragLayer(collect) {
  var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

_utilsCheckDecoratorArguments2['default'].apply(undefined, ['DragLayer', 'collect[, options]'].concat(_slice.call(arguments)));
  _invariant2['default'](typeof collect === 'function', 'Expected "collect" provided as the first argument to DragLayer ' + 'to be a function that collects props to inject into the component. ', 'Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-layer.html', collect);
  _invariant2['default'](_lodashIsPlainObject2['default'](options), 'Expected "options" provided as the second argument to DragLayer to be ' + 'a plain object when specified. ' + 'Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-layer.html', options);

return function decorateLayer(DecoratedComponent) {
    var _options$arePropsEqual = options.arePropsEqual;
    var arePropsEqual = _options$arePropsEqual === undefined ? _utilsShallowEqualScalar2['default'] : _options$arePropsEqual;

var displayName = DecoratedComponent.displayName || DecoratedComponent.name || 'Component';

return (function (_Component) {
      _inherits(DragLayerContainer, _Component);

DragLayerContainer.prototype.getDecoratedComponentInstance = function getDecoratedComponentInstance() {
        return this.refs.child;
      };

DragLayerContainer.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {
        return !arePropsEqual(nextProps, this.props) || !_utilsShallowEqual2['default'](nextState, this.state);
      };

_createClass(DragLayerContainer, null, [{
        key: 'DecoratedComponent',
        value: DecoratedComponent,
        enumerable: true
      }, {
        key: 'displayName',
        value: 'DragLayer(' + displayName + ')',
        enumerable: true
      }, {
        key: 'contextTypes',
        value: {
          dragDropManager: _react.PropTypes.object.isRequired
        },
        enumerable: true
      }]);

function DragLayerContainer(props, context) {
        _classCallCheck(this, DragLayerContainer);

_Component.call(this, props);
        this.handleChange = this.handleChange.bind(this);

this.manager = context.dragDropManager;
        _invariant2['default'](typeof this.manager === 'object', 'Could not find the drag and drop manager in the context of %s. ' + 'Make sure to wrap the top-level component of your app with DragDropContext. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-troubleshooting.html#could-not-find-the-drag-and-drop-manager-in-the-context', displayName, displayName);

this.state = this.getCurrentState();
      }

DragLayerContainer.prototype.componentDidMount = function componentDidMount() {
        this.isCurrentlyMounted = true;

var monitor = this.manager.getMonitor();
        this.unsubscribeFromOffsetChange = monitor.subscribeToOffsetChange(this.handleChange);
        this.unsubscribeFromStateChange = monitor.subscribeToStateChange(this.handleChange);

this.handleChange();
      };

DragLayerContainer.prototype.componentWillUnmount = function componentWillUnmount() {
        this.isCurrentlyMounted = false;

this.unsubscribeFromOffsetChange();
        this.unsubscribeFromStateChange();
      };

DragLayerContainer.prototype.handleChange = function handleChange() {
        if (!this.isCurrentlyMounted) {
          return;
        }

var nextState = this.getCurrentState();
        if (!_utilsShallowEqual2['default'](nextState, this.state)) {
          this.setState(nextState);
        }
      };

DragLayerContainer.prototype.getCurrentState = function getCurrentState() {
        var monitor = this.manager.getMonitor();
        return collect(monitor);
      };

DragLayerContainer.prototype.render = function render() {
        return _react2['default'].createElement(DecoratedComponent, _extends({}, this.props, this.state, {
          ref: 'child' }));
      };

return DragLayerContainer;
    })(_react.Component);
  };
}

module.exports = exports['default'];

/***/ }),
/* 1225 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
var _slice = Array.prototype.slice;
exports['default'] = DragSource;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _lodashIsPlainObject = __webpack_require__(48);

var _lodashIsPlainObject2 = _interopRequireDefault(_lodashIsPlainObject);

var _utilsCheckDecoratorArguments = __webpack_require__(186);

var _utilsCheckDecoratorArguments2 = _interopRequireDefault(_utilsCheckDecoratorArguments);

var _decorateHandler = __webpack_require__(487);

var _decorateHandler2 = _interopRequireDefault(_decorateHandler);

var _registerSource = __webpack_require__(1233);

var _registerSource2 = _interopRequireDefault(_registerSource);

var _createSourceFactory = __webpack_require__(1228);

var _createSourceFactory2 = _interopRequireDefault(_createSourceFactory);

var _createSourceMonitor = __webpack_require__(1229);

var _createSourceMonitor2 = _interopRequireDefault(_createSourceMonitor);

var _createSourceConnector = __webpack_require__(1227);

var _createSourceConnector2 = _interopRequireDefault(_createSourceConnector);

var _utilsIsValidType = __webpack_require__(488);

var _utilsIsValidType2 = _interopRequireDefault(_utilsIsValidType);

function DragSource(type, spec, collect) {
  var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];

_utilsCheckDecoratorArguments2['default'].apply(undefined, ['DragSource', 'type, spec, collect[, options]'].concat(_slice.call(arguments)));
  var getType = type;
  if (typeof type !== 'function') {
    _invariant2['default'](_utilsIsValidType2['default'](type), 'Expected "type" provided as the first argument to DragSource to be ' + 'a string, or a function that returns a string given the current props. ' + 'Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source.html', type);
    getType = function () {
      return type;
    };
  }
  _invariant2['default'](_lodashIsPlainObject2['default'](spec), 'Expected "spec" provided as the second argument to DragSource to be ' + 'a plain object. Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source.html', spec);
  var createSource = _createSourceFactory2['default'](spec);
  _invariant2['default'](typeof collect === 'function', 'Expected "collect" provided as the third argument to DragSource to be ' + 'a function that returns a plain object of props to inject. ' + 'Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source.html', collect);
  _invariant2['default'](_lodashIsPlainObject2['default'](options), 'Expected "options" provided as the fourth argument to DragSource to be ' + 'a plain object when specified. ' + 'Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source.html', collect);

return function decorateSource(DecoratedComponent) {
    return _decorateHandler2['default']({
      connectBackend: function connectBackend(backend, sourceId) {
        return backend.connectDragSource(sourceId);
      },
      containerDisplayName: 'DragSource',
      createHandler: createSource,
      registerHandler: _registerSource2['default'],
      createMonitor: _createSourceMonitor2['default'],
      createConnector: _createSourceConnector2['default'],
      DecoratedComponent: DecoratedComponent,
      getType: getType,
      collect: collect,
      options: options
    });
  };
}

module.exports = exports['default'];

/***/ }),
/* 1226 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
var _slice = Array.prototype.slice;
exports['default'] = DropTarget;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _lodashIsPlainObject = __webpack_require__(48);

var _lodashIsPlainObject2 = _interopRequireDefault(_lodashIsPlainObject);

var _utilsCheckDecoratorArguments = __webpack_require__(186);

var _utilsCheckDecoratorArguments2 = _interopRequireDefault(_utilsCheckDecoratorArguments);

var _decorateHandler = __webpack_require__(487);

var _decorateHandler2 = _interopRequireDefault(_decorateHandler);

var _registerTarget = __webpack_require__(1234);

var _registerTarget2 = _interopRequireDefault(_registerTarget);

var _createTargetFactory = __webpack_require__(1231);

var _createTargetFactory2 = _interopRequireDefault(_createTargetFactory);

var _createTargetMonitor = __webpack_require__(1232);

var _createTargetMonitor2 = _interopRequireDefault(_createTargetMonitor);

var _createTargetConnector = __webpack_require__(1230);

var _createTargetConnector2 = _interopRequireDefault(_createTargetConnector);

var _utilsIsValidType = __webpack_require__(488);

var _utilsIsValidType2 = _interopRequireDefault(_utilsIsValidType);

function DropTarget(type, spec, collect) {
  var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];

_utilsCheckDecoratorArguments2['default'].apply(undefined, ['DropTarget', 'type, spec, collect[, options]'].concat(_slice.call(arguments)));
  var getType = type;
  if (typeof type !== 'function') {
    _invariant2['default'](_utilsIsValidType2['default'](type, true), 'Expected "type" provided as the first argument to DropTarget to be ' + 'a string, an array of strings, or a function that returns either given ' + 'the current props. Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drop-target.html', type);
    getType = function () {
      return type;
    };
  }
  _invariant2['default'](_lodashIsPlainObject2['default'](spec), 'Expected "spec" provided as the second argument to DropTarget to be ' + 'a plain object. Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drop-target.html', spec);
  var createTarget = _createTargetFactory2['default'](spec);
  _invariant2['default'](typeof collect === 'function', 'Expected "collect" provided as the third argument to DropTarget to be ' + 'a function that returns a plain object of props to inject. ' + 'Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drop-target.html', collect);
  _invariant2['default'](_lodashIsPlainObject2['default'](options), 'Expected "options" provided as the fourth argument to DropTarget to be ' + 'a plain object when specified. ' + 'Instead, received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drop-target.html', collect);

return function decorateTarget(DecoratedComponent) {
    return _decorateHandler2['default']({
      connectBackend: function connectBackend(backend, targetId) {
        return backend.connectDropTarget(targetId);
      },
      containerDisplayName: 'DropTarget',
      createHandler: createTarget,
      registerHandler: _registerTarget2['default'],
      createMonitor: _createTargetMonitor2['default'],
      createConnector: _createTargetConnector2['default'],
      DecoratedComponent: DecoratedComponent,
      getType: getType,
      collect: collect,
      options: options
    });
  };
}

module.exports = exports['default'];

/***/ }),
/* 1227 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = createSourceConnector;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _wrapConnectorHooks = __webpack_require__(490);

var _wrapConnectorHooks2 = _interopRequireDefault(_wrapConnectorHooks);

var _areOptionsEqual = __webpack_require__(486);

var _areOptionsEqual2 = _interopRequireDefault(_areOptionsEqual);

function createSourceConnector(backend) {
  var currentHandlerId = undefined;

var currentDragSourceNode = undefined;
  var currentDragSourceOptions = undefined;
  var disconnectCurrentDragSource = undefined;

var currentDragPreviewNode = undefined;
  var currentDragPreviewOptions = undefined;
  var disconnectCurrentDragPreview = undefined;

function reconnectDragSource() {
    if (disconnectCurrentDragSource) {
      disconnectCurrentDragSource();
      disconnectCurrentDragSource = null;
    }

if (currentHandlerId && currentDragSourceNode) {
      disconnectCurrentDragSource = backend.connectDragSource(currentHandlerId, currentDragSourceNode, currentDragSourceOptions);
    }
  }

function reconnectDragPreview() {
    if (disconnectCurrentDragPreview) {
      disconnectCurrentDragPreview();
      disconnectCurrentDragPreview = null;
    }

if (currentHandlerId && currentDragPreviewNode) {
      disconnectCurrentDragPreview = backend.connectDragPreview(currentHandlerId, currentDragPreviewNode, currentDragPreviewOptions);
    }
  }

function receiveHandlerId(handlerId) {
    if (handlerId === currentHandlerId) {
      return;
    }

currentHandlerId = handlerId;
    reconnectDragSource();
    reconnectDragPreview();
  }

var hooks = _wrapConnectorHooks2['default']({
    dragSource: function connectDragSource(node, options) {
      if (node === currentDragSourceNode && _areOptionsEqual2['default'](options, currentDragSourceOptions)) {
        return;
      }

currentDragSourceNode = node;
      currentDragSourceOptions = options;

reconnectDragSource();
    },

dragPreview: function connectDragPreview(node, options) {
      if (node === currentDragPreviewNode && _areOptionsEqual2['default'](options, currentDragPreviewOptions)) {
        return;
      }

currentDragPreviewNode = node;
      currentDragPreviewOptions = options;

reconnectDragPreview();
    }
  });

return {
    receiveHandlerId: receiveHandlerId,
    hooks: hooks
  };
}

module.exports = exports['default'];

/***/ }),
/* 1228 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports['default'] = createSourceFactory;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _lodashIsPlainObject = __webpack_require__(48);

var _lodashIsPlainObject2 = _interopRequireDefault(_lodashIsPlainObject);

var ALLOWED_SPEC_METHODS = ['canDrag', 'beginDrag', 'canDrag', 'isDragging', 'endDrag'];
var REQUIRED_SPEC_METHODS = ['beginDrag'];

function createSourceFactory(spec) {
  Object.keys(spec).forEach(function (key) {
    _invariant2['default'](ALLOWED_SPEC_METHODS.indexOf(key) > -1, 'Expected the drag source specification to only have ' + 'some of the following keys: %s. ' + 'Instead received a specification with an unexpected "%s" key. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source.html', ALLOWED_SPEC_METHODS.join(', '), key);
    _invariant2['default'](typeof spec[key] === 'function', 'Expected %s in the drag source specification to be a function. ' + 'Instead received a specification with %s: %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source.html', key, key, spec[key]);
  });
  REQUIRED_SPEC_METHODS.forEach(function (key) {
    _invariant2['default'](typeof spec[key] === 'function', 'Expected %s in the drag source specification to be a function. ' + 'Instead received a specification with %s: %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source.html', key, key, spec[key]);
  });

var Source = (function () {
    function Source(monitor) {
      _classCallCheck(this, Source);

this.monitor = monitor;
      this.props = null;
      this.component = null;
    }

Source.prototype.receiveProps = function receiveProps(props) {
      this.props = props;
    };

Source.prototype.receiveComponent = function receiveComponent(component) {
      this.component = component;
    };

Source.prototype.canDrag = function canDrag() {
      if (!spec.canDrag) {
        return true;
      }

return spec.canDrag(this.props, this.monitor);
    };

Source.prototype.isDragging = function isDragging(globalMonitor, sourceId) {
      if (!spec.isDragging) {
        return sourceId === globalMonitor.getSourceId();
      }

return spec.isDragging(this.props, this.monitor);
    };

Source.prototype.beginDrag = function beginDrag() {
      var item = spec.beginDrag(this.props, this.monitor, this.component);
      if (process.env.NODE_ENV !== 'production') {
        _invariant2['default'](_lodashIsPlainObject2['default'](item), 'beginDrag() must return a plain object that represents the dragged item. ' + 'Instead received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source.html', item);
      }
      return item;
    };

Source.prototype.endDrag = function endDrag() {
      if (!spec.endDrag) {
        return;
      }

spec.endDrag(this.props, this.monitor, this.component);
    };

return Source;
  })();

return function createSource(monitor) {
    return new Source(monitor);
  };
}

module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1229 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = createSourceMonitor;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var isCallingCanDrag = false;
var isCallingIsDragging = false;

var SourceMonitor = (function () {
  function SourceMonitor(manager) {
    _classCallCheck(this, SourceMonitor);

this.internalMonitor = manager.getMonitor();
  }

SourceMonitor.prototype.receiveHandlerId = function receiveHandlerId(sourceId) {
    this.sourceId = sourceId;
  };

SourceMonitor.prototype.canDrag = function canDrag() {
    _invariant2['default'](!isCallingCanDrag, 'You may not call monitor.canDrag() inside your canDrag() implementation. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source-monitor.html');

try {
      isCallingCanDrag = true;
      return this.internalMonitor.canDragSource(this.sourceId);
    } finally {
      isCallingCanDrag = false;
    }
  };

SourceMonitor.prototype.isDragging = function isDragging() {
    _invariant2['default'](!isCallingIsDragging, 'You may not call monitor.isDragging() inside your isDragging() implementation. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drag-source-monitor.html');

try {
      isCallingIsDragging = true;
      return this.internalMonitor.isDraggingSource(this.sourceId);
    } finally {
      isCallingIsDragging = false;
    }
  };

SourceMonitor.prototype.getItemType = function getItemType() {
    return this.internalMonitor.getItemType();
  };

SourceMonitor.prototype.getItem = function getItem() {
    return this.internalMonitor.getItem();
  };

SourceMonitor.prototype.getDropResult = function getDropResult() {
    return this.internalMonitor.getDropResult();
  };

SourceMonitor.prototype.didDrop = function didDrop() {
    return this.internalMonitor.didDrop();
  };

SourceMonitor.prototype.getInitialClientOffset = function getInitialClientOffset() {
    return this.internalMonitor.getInitialClientOffset();
  };

SourceMonitor.prototype.getInitialSourceClientOffset = function getInitialSourceClientOffset() {
    return this.internalMonitor.getInitialSourceClientOffset();
  };

SourceMonitor.prototype.getSourceClientOffset = function getSourceClientOffset() {
    return this.internalMonitor.getSourceClientOffset();
  };

SourceMonitor.prototype.getClientOffset = function getClientOffset() {
    return this.internalMonitor.getClientOffset();
  };

SourceMonitor.prototype.getDifferenceFromInitialOffset = function getDifferenceFromInitialOffset() {
    return this.internalMonitor.getDifferenceFromInitialOffset();
  };

return SourceMonitor;
})();

function createSourceMonitor(manager) {
  return new SourceMonitor(manager);
}

module.exports = exports['default'];

/***/ }),
/* 1230 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = createTargetConnector;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _wrapConnectorHooks = __webpack_require__(490);

var _wrapConnectorHooks2 = _interopRequireDefault(_wrapConnectorHooks);

var _areOptionsEqual = __webpack_require__(486);

var _areOptionsEqual2 = _interopRequireDefault(_areOptionsEqual);

function createTargetConnector(backend) {
  var currentHandlerId = undefined;

var currentDropTargetNode = undefined;
  var currentDropTargetOptions = undefined;
  var disconnectCurrentDropTarget = undefined;

function reconnectDropTarget() {
    if (disconnectCurrentDropTarget) {
      disconnectCurrentDropTarget();
      disconnectCurrentDropTarget = null;
    }

if (currentHandlerId && currentDropTargetNode) {
      disconnectCurrentDropTarget = backend.connectDropTarget(currentHandlerId, currentDropTargetNode, currentDropTargetOptions);
    }
  }

function receiveHandlerId(handlerId) {
    if (handlerId === currentHandlerId) {
      return;
    }

currentHandlerId = handlerId;
    reconnectDropTarget();
  }

var hooks = _wrapConnectorHooks2['default']({
    dropTarget: function connectDropTarget(node, options) {
      if (node === currentDropTargetNode && _areOptionsEqual2['default'](options, currentDropTargetOptions)) {
        return;
      }

currentDropTargetNode = node;
      currentDropTargetOptions = options;

reconnectDropTarget();
    }
  });

return {
    receiveHandlerId: receiveHandlerId,
    hooks: hooks
  };
}

module.exports = exports['default'];

/***/ }),
/* 1231 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports['default'] = createTargetFactory;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _lodashIsPlainObject = __webpack_require__(48);

var _lodashIsPlainObject2 = _interopRequireDefault(_lodashIsPlainObject);

var ALLOWED_SPEC_METHODS = ['canDrop', 'hover', 'drop'];

function createTargetFactory(spec) {
  Object.keys(spec).forEach(function (key) {
    _invariant2['default'](ALLOWED_SPEC_METHODS.indexOf(key) > -1, 'Expected the drop target specification to only have ' + 'some of the following keys: %s. ' + 'Instead received a specification with an unexpected "%s" key. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drop-target.html', ALLOWED_SPEC_METHODS.join(', '), key);
    _invariant2['default'](typeof spec[key] === 'function', 'Expected %s in the drop target specification to be a function. ' + 'Instead received a specification with %s: %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drop-target.html', key, key, spec[key]);
  });

var Target = (function () {
    function Target(monitor) {
      _classCallCheck(this, Target);

this.monitor = monitor;
      this.props = null;
      this.component = null;
    }

Target.prototype.receiveProps = function receiveProps(props) {
      this.props = props;
    };

Target.prototype.receiveMonitor = function receiveMonitor(monitor) {
      this.monitor = monitor;
    };

Target.prototype.receiveComponent = function receiveComponent(component) {
      this.component = component;
    };

Target.prototype.canDrop = function canDrop() {
      if (!spec.canDrop) {
        return true;
      }

return spec.canDrop(this.props, this.monitor);
    };

Target.prototype.hover = function hover() {
      if (!spec.hover) {
        return;
      }

spec.hover(this.props, this.monitor, this.component);
    };

Target.prototype.drop = function drop() {
      if (!spec.drop) {
        return;
      }

var dropResult = spec.drop(this.props, this.monitor, this.component);
      if (process.env.NODE_ENV !== 'production') {
        _invariant2['default'](typeof dropResult === 'undefined' || _lodashIsPlainObject2['default'](dropResult), 'drop() must either return undefined, or an object that represents the drop result. ' + 'Instead received %s. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drop-target.html', dropResult);
      }
      return dropResult;
    };

return Target;
  })();

return function createTarget(monitor) {
    return new Target(monitor);
  };
}

module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1232 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = createTargetMonitor;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var isCallingCanDrop = false;

var TargetMonitor = (function () {
  function TargetMonitor(manager) {
    _classCallCheck(this, TargetMonitor);

this.internalMonitor = manager.getMonitor();
  }

TargetMonitor.prototype.receiveHandlerId = function receiveHandlerId(targetId) {
    this.targetId = targetId;
  };

TargetMonitor.prototype.canDrop = function canDrop() {
    _invariant2['default'](!isCallingCanDrop, 'You may not call monitor.canDrop() inside your canDrop() implementation. ' + 'Read more: http://gaearon.github.io/react-dnd/docs-drop-target-monitor.html');

try {
      isCallingCanDrop = true;
      return this.internalMonitor.canDropOnTarget(this.targetId);
    } finally {
      isCallingCanDrop = false;
    }
  };

TargetMonitor.prototype.isOver = function isOver(options) {
    return this.internalMonitor.isOverTarget(this.targetId, options);
  };

TargetMonitor.prototype.getItemType = function getItemType() {
    return this.internalMonitor.getItemType();
  };

TargetMonitor.prototype.getItem = function getItem() {
    return this.internalMonitor.getItem();
  };

TargetMonitor.prototype.getDropResult = function getDropResult() {
    return this.internalMonitor.getDropResult();
  };

TargetMonitor.prototype.didDrop = function didDrop() {
    return this.internalMonitor.didDrop();
  };

TargetMonitor.prototype.getInitialClientOffset = function getInitialClientOffset() {
    return this.internalMonitor.getInitialClientOffset();
  };

TargetMonitor.prototype.getInitialSourceClientOffset = function getInitialSourceClientOffset() {
    return this.internalMonitor.getInitialSourceClientOffset();
  };

TargetMonitor.prototype.getSourceClientOffset = function getSourceClientOffset() {
    return this.internalMonitor.getSourceClientOffset();
  };

TargetMonitor.prototype.getClientOffset = function getClientOffset() {
    return this.internalMonitor.getClientOffset();
  };

TargetMonitor.prototype.getDifferenceFromInitialOffset = function getDifferenceFromInitialOffset() {
    return this.internalMonitor.getDifferenceFromInitialOffset();
  };

return TargetMonitor;
})();

function createTargetMonitor(manager) {
  return new TargetMonitor(manager);
}

module.exports = exports['default'];

/***/ }),
/* 1233 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports["default"] = registerSource;

function registerSource(type, source, manager) {
  var registry = manager.getRegistry();
  var sourceId = registry.addSource(type, source);

function unregisterSource() {
    registry.removeSource(sourceId);
  }

return {
    handlerId: sourceId,
    unregister: unregisterSource
  };
}

module.exports = exports["default"];

/***/ }),
/* 1234 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports["default"] = registerTarget;

function registerTarget(type, target, manager) {
  var registry = manager.getRegistry();
  var targetId = registry.addTarget(type, target);

function unregisterTarget() {
    registry.removeTarget(targetId);
  }

return {
    handlerId: targetId,
    unregister: unregisterTarget
  };
}

module.exports = exports["default"];

/***/ }),
/* 1235 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports['default'] = cloneWithRef;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _react = __webpack_require__(0);

function cloneWithRef(element, newRef) {
  var previousRef = element.ref;
  _invariant2['default'](typeof previousRef !== 'string', 'Cannot connect React DnD to an element with an existing string ref. ' + 'Please convert it to use a callback ref instead, or wrap it into a <span> or <div>. ' + 'Read more: https://facebook.github.io/react/docs/more-about-refs.html#the-ref-callback-attribute');

if (!previousRef) {
    // When there is no ref on the element, use the new ref directly
    return _react.cloneElement(element, {
      ref: newRef
    });
  }

return _react.cloneElement(element, {
    ref: function ref(node) {
      newRef(node);

if (previousRef) {
        previousRef(node);
      }
    }
  });
}

module.exports = exports['default'];

/***/ }),
/* 1236 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = __webpack_require__(1372);

/***/ }),
/* 1237 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _class; /**
             * React Flip Move
             * (c) 2016-present Joshua Comeau
             *
             * How it works:
             * The basic idea with this component is pretty straightforward:
             *
             *   - We track all rendered elements by their `key` property, and we keep
             *     their bounding boxes (their top/left/right/bottom coordinates) in this
             *     component's state.
             *   - When the component updates, we compare its former position (held in
             *     state) with its new position (derived from the DOM after update).
             *   - If the two have moved, we use the FLIP technique to animate the
             *     transition between their positions.
             */

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactDom = __webpack_require__(7);

var _reactDom2 = _interopRequireDefault(_reactDom);

__webpack_require__(1239);

var _propConverter = __webpack_require__(1240);

var _propConverter2 = _interopRequireDefault(_propConverter);

var _helpers = __webpack_require__(491);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var transitionEnd = (0, _helpers.whichTransitionEvent)();

var FlipMove = (0, _propConverter2.default)(_class = function (_Component) {
  _inherits(FlipMove, _Component);

function FlipMove(props) {
    _classCallCheck(this, FlipMove);

var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(FlipMove).call(this, props));

_this.boundingBoxes = {};

_this.parentElement = null;
    _this.parentBox = null;

_this.doesChildNeedToBeAnimated = _this.doesChildNeedToBeAnimated.bind(_this);

// Copy props.children into state.
    // To understand why this is important (and not an anti-pattern), consider
    // how "leave" animations work. An item has "left" when the component
    // receives a new set of props that do NOT contain the item.
    // If we just render the props as-is, the item would instantly disappear.
    // We want to keep the item rendered for a little while, until its animation
    // can complete. Because we cannot mutate props, we make `state` the source
    // of truth.
    _this.state = { children: props.children };

// Keep track of remaining animations so we know when to fire the
    // all-finished callback, and clean up after ourselves.
    _this.remainingAnimations = 0;
    _this.childrenToAnimate = {
      elements: [],
      domNodes: []
    };

// When leaving items, we apply some over-ride styles to them (position,
    // top, left). If the item is passed in through props BEFORE the item has
    // finished leaving, its style will be wrong. So, to prevent any weirdness,
    // we store the "original" styles here so they can be applied on re-entry.
    // A crazy edge case, I know.
    _this.originalDomStyles = {};
    return _this;
  }

_createClass(FlipMove, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      this.parentElement = _reactDom2.default.findDOMNode(this);
    }
  }, {
    key: 'componentDidUpdate',
    value: function componentDidUpdate(previousProps) {
      // If the children have been re-arranged, moved, or added/removed,
      // trigger the main FLIP animation.
      //
      // This check is required so that we don't trigger a re-animation when the
      // `onFinishAll` handler is called, at the end of the animation, to remove
      // exited nodes.
      if (this.props.children !== previousProps.children) {
        this.calculateAndAnimateChildren();
      }
    }
  }, {
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      var _this2 = this;

// When the component is handed new props, we need to figure out the "resting"
      // position of all currently-rendered DOM nodes. We store that data in
      // this.boundingBoxes, so it can be used later to work out the animation.

// Calculate the parentBox. This is used to find childBoxes relative
      // to the parent container, not the viewport.
      var parentBox = this.props.getPosition(this.parentElement);

// Get the bounding boxes of all currently-rendered, keyed children.
      var newBoundingBoxes = this.props.children.reduce(function (boxes, child) {
        // It is possible that a child does not have a `key` property;
        // Ignore these children, they don't need to be moved.
        if (!child.key) return boxes;

var domNode = _reactDom2.default.findDOMNode(_this2.refs[child.key]);

var childBox = _this2.props.getPosition(domNode);
        var relativeBox = {
          'top': childBox['top'] - parentBox['top'],
          'left': childBox['left'] - parentBox['left'],
          'right': parentBox['right'] - childBox['right'],
          'bottom': parentBox['bottom'] - childBox['bottom']
        };

return _extends({}, boxes, _defineProperty({}, child.key, relativeBox));
      }, {});

this.boundingBoxes = _extends({}, this.boundingBoxes, newBoundingBoxes);

// Create our custom list of items.
      // We use this list instead of props so that we can mutate it.
      // We're keeping just-deleted nodes for a bit longer, as well as adding a
      // flag to just-created nodes, so we know they need to be entered.
      this.setState({
        children: this.prepareNextChildren(nextProps.children)
      });
    }
  }, {
    key: 'prepareNextChildren',
    value: function prepareNextChildren(nextChildren) {
      var _this3 = this;

// We want to:
      //   - Mark all new children as `entering`
      //   - Pull in previous children that aren't in nextChildren, and mark them
      //     as `leaving`
      //   - Preserve the nextChildren list order, with leaving children in their
      //     appropriate places.
      //

// Start by marking new children as 'entering'
      var updatedChildren = nextChildren.map(function (nextChild) {
        var child = _this3.state.children.find(function (_ref) {
          var key = _ref.key;
          return key === nextChild.key;
        });

// If the current child did exist, but it was in the middle of leaving,
        // we want to treat it as though it's entering
        var isEntering = !child || child.leaving;

return _extends({}, nextChild, { entering: isEntering });
      });

// This is tricky. We want to keep the nextChildren's ordering, but with
      // any just-removed items maintaining their original position.
      // eg.
      //   this.state.children  = [ 1, 2, 3, 4 ]
      //   nextChildren         = [ 3, 1 ]
      //
      // In this example, we've removed the '2' & '4'
      // We want to end up with:  [ 2, 3, 1, 4 ]
      //
      // To accomplish that, we'll iterate through this.state.children. whenever
      // we find a match, we'll append our `leaving` flag to it, and insert it
      // into the nextChildren in its ORIGINAL position. Note that, as we keep
      // inserting old items into the new list, the "original" position will
      // keep incrementing.
      var numOfChildrenLeaving = 0;
      this.state.children.forEach(function (child, index) {
        var isLeaving = !nextChildren.find(function (_ref2) {
          var key = _ref2.key;
          return key === child.key;
        });

// If the child isn't leaving (or, if there is no leave animation),
        // we don't need to add it into the state children.
        if (!isLeaving || !_this3.props.leaveAnimation) return;

var nextChild = _extends({}, child, { leaving: true });
        var nextChildIndex = index + numOfChildrenLeaving;

updatedChildren.splice(nextChildIndex, 0, nextChild);
        numOfChildrenLeaving++;
      });

return updatedChildren;
    }
  }, {
    key: 'calculateAndAnimateChildren',
    value: function calculateAndAnimateChildren() {
      var _this4 = this;

// Re-calculate the bounding boxes of tracked elements.
      // Compare to the bounding boxes stored in state.
      // Animate as required =)

// There are two situations in which we want to skip all animations.
      //   - Developer has specifically disabled animations
      //   - User is running in a browser without CSS transition support
      //
      // In either case, simply set the children to their new values.
      if (this.isAnimationDisabled() || !transitionEnd) {
        return this.setState({ children: this.props.children });
      }

this.parentBox = this.props.getPosition(this.parentElement);

// we need to make all leaving nodes "invisible" to the layout calculations
      // that will take place in the next step (this.runAnimation).
      if (this.props.leaveAnimation) {
        var leavingChildren = this.state.children.filter(function (_ref3) {
          var leaving = _ref3.leaving;
          return leaving;
        });

leavingChildren.forEach(function (leavingChild) {
          var domNode = _reactDom2.default.findDOMNode(_this4.refs[leavingChild.key]);
          var leavingBoundingBox = _this4.boundingBoxes[leavingChild.key];

// We need to take the items out of the "flow" of the document, so that
          // its siblings can move to take its place.
          // By setting its position to absolute and positioning it where it is,
          // we can make it leave in-place while its siblings can calculate where
          // they need to go.
          // If, however, the 'leave' is interrupted and they're forced to re-enter,
          // we want to undo this change, and the only way to do that is to preserve
          // their current styles.
          _this4.originalDomStyles[leavingChild.key] = {
            position: domNode.style.position,
            top: domNode.style.top,
            left: domNode.style.left,
            right: domNode.style.right
          };

// For this to work, we have to offset any given `margin`.
          var computed = window.getComputedStyle(domNode);
          var cleanedComputed = {};

// Clean up the properties (remove 'px', convert to Number).
          ['margin-top', 'margin-left', 'margin-right'].forEach(function (margin) {
            var propertyVal = computed.getPropertyValue(margin);
            cleanedComputed[margin] = Number(propertyVal.replace('px', ''));
          });

domNode.style.position = 'absolute';
          domNode.style.top = leavingBoundingBox.top - cleanedComputed['margin-top'] + 'px';
          domNode.style.left = leavingBoundingBox.left - cleanedComputed['margin-left'] + 'px';
          domNode.style.right = leavingBoundingBox.right - cleanedComputed['margin-right'] + 'px';
        });
      }

var dynamicChildren = this.state.children.filter(this.doesChildNeedToBeAnimated);

// Next, we need to do all our new layout calculations, and get our new
      // styles for each item. We'll organize it as an object where the keys
      // are the item key, and the value is their new 'style'.
      this.domStyles = dynamicChildren.reduce(function (memo, child) {
        memo[child.key] = _this4.computeInitialStyles(child);
        return memo;
      }, {});

// Now that the styles are computed, animate each child individually.
      dynamicChildren.forEach(function (child, index) {
        _this4.addChildToAnimationsList(child);
        _this4.runAnimation(child, index);
      });

// Trigger the onStartAll callback, if provided.
      if (this.props.onStartAll) {
        this.props.onStartAll(this.childrenToAnimate.elements, this.childrenToAnimate.domNodes);
      }
    }
  }, {
    key: 'computeInitialStyles',
    value: function computeInitialStyles(child) {
      var style = { transition: '0ms' };

if (child.entering) {
        if (this.props.enterAnimation) {
          var original = this.originalDomStyles[child.key] || {};
          style = _extends({}, style, this.props.enterAnimation.from, original);
        }
      } else if (child.leaving) {
        if (this.props.leaveAnimation) {
          style = _extends({}, style, this.props.leaveAnimation.from);
        }
      } else {
        var domNode = _reactDom2.default.findDOMNode(this.refs[child.key]);

var _getPositionDelta = this.getPositionDelta(domNode, child.key);

var _getPositionDelta2 = _slicedToArray(_getPositionDelta, 2);

var dX = _getPositionDelta2[0];
        var dY = _getPositionDelta2[1];

style.transform = 'translate(' + dX + 'px, ' + dY + 'px)';
      }

return style;
    }
  }, {
    key: 'isAnimationDisabled',
    value: function isAnimationDisabled() {
      // If the component is explicitly passed a `disableAllAnimations` flag,
      // we can skip this whole process. Similarly, if all of the numbers have
      // been set to 0, there is no point in trying to animate; doing so would
      // only cause a flicker (and the intent is probably to disable animations)
      return this.props.disableAllAnimations || this.props.duration === 0 && this.props.delay === 0 && this.props.staggerDurationBy === 0 && this.props.staggerDelayBy === 0;
    }
  }, {
    key: 'doesChildNeedToBeAnimated',
    value: function doesChildNeedToBeAnimated(child) {
      // If the child doesn't have a key, it's an immovable child (one that we
      // do not want to do flip stuff to.)
      if (!child.key) return;

if (child.entering && this.props.enterAnimation || child.leaving && this.props.leaveAnimation) {
        return true;
      }

// Otherwise, we only want to animate it if the child's position on-screen
      // has changed. Let's figure that out.
      var domNode = _reactDom2.default.findDOMNode(this.refs[child.key]);

var _getPositionDelta3 = this.getPositionDelta(domNode, child.key);

var _getPositionDelta4 = _slicedToArray(_getPositionDelta3, 2);

var dX = _getPositionDelta4[0];
      var dY = _getPositionDelta4[1];

return dX !== 0 || dY !== 0;
    }
  }, {
    key: 'addChildToAnimationsList',
    value: function addChildToAnimationsList(child) {
      // Add this child to the animations array. This is used for working out
      // when all children have finished animated (so that the onFinishAll
      // callback can be fired, and so we can do some cleanup).
      var domNode = _reactDom2.default.findDOMNode(this.refs[child.key]);

this.remainingAnimations++;
      this.childrenToAnimate.elements.push(child);
      this.childrenToAnimate.domNodes.push(domNode);
    }
  }, {
    key: 'runAnimation',
    value: function runAnimation(child, n) {
      var _this5 = this;

var domNode = _reactDom2.default.findDOMNode(this.refs[child.key]);
      var styles = this.domStyles[child.key];

// Apply the relevant style for this DOM node
      // This is the offset from its actual DOM position.
      // eg. if an item has been re-rendered 20px lower, we want to apply a
      // style of 'transform: translate(-20px)', so that it appears to be where
      // it started.
      (0, _helpers.applyStylesToDOMNode)(domNode, styles);

//// A note on the double-requestAnimationFrame:
      //// Sadly, this is the most browser-compatible way to do this I've found.
      //// Essentially we need to set the initial styles outside of any request
      //// callbacks to avoid batching them. Then, a frame needs to pass with
      //// the styles above rendered. Then, on the second frame, we can apply
      //// our final styles to perform the animation.
      requestAnimationFrame(function () {
        requestAnimationFrame(function () {
          // Our first order of business is to "undo" the styles applied in the
          // previous frames, while also adding a `transition` property.
          // This way, the item will smoothly transition from its old position
          // to its new position.
          var styles = {
            transition: _this5.createTransitionString(n),
            transform: '',
            opacity: ''
          };

if (child.entering && _this5.props.enterAnimation) {
            styles = _extends({}, styles, _this5.props.enterAnimation.to);
          } else if (child.leaving && _this5.props.leaveAnimation) {
            styles = _extends({}, styles, _this5.props.leaveAnimation.to);
          }

(0, _helpers.applyStylesToDOMNode)(domNode, styles);
        });
      });

// Trigger the onStart callback immediately.
      if (this.props.onStart) this.props.onStart(child, domNode);

// The onFinish callback needs to be bound to the transitionEnd event.
      // We also need to unbind it when the transition completes, so this ugly
      // inline function is required (we need it here so it closes over
      // dependent variables `child` and `domNode`)
      var transitionEndHandler = function transitionEndHandler(ev) {
        // It's possible that this handler is fired not on our primary transition,
        // but on a nested transition (eg. a hover effect). Ignore these cases.
        if (ev.target !== domNode) return;

// Remove the 'transition' inline style we added. This is cleanup.
        domNode.style.transition = '';

// Trigger any applicable onFinish/onFinishAll hooks
        _this5.triggerFinishHooks(child, domNode);

domNode.removeEventListener(transitionEnd, transitionEndHandler);
      };

domNode.addEventListener(transitionEnd, transitionEndHandler);
    }
  }, {
    key: 'getPositionDelta',
    value: function getPositionDelta(domNode, key) {
      // TEMP: A mystery bug is sometimes causing unnecessary boundingBoxes to
      // remain. Until this bug can be solved, this band-aid fix does the job:
      var defaultBox = { left: 0, top: 0 };
      var newBox = this.props.getPosition(domNode);
      var oldBox = this.boundingBoxes[key] || defaultBox;
      var relativeBox = {
        top: newBox.top - this.parentBox.top,
        left: newBox.left - this.parentBox.left
      };

return [oldBox.left - relativeBox.left, oldBox.top - relativeBox.top];
    }
  }, {
    key: 'createTransitionString',
    value: function createTransitionString(n) {
      var props = arguments.length <= 1 || arguments[1] === undefined ? ['transform', 'opacity'] : arguments[1];
      var _props = this.props;
      var duration = _props.duration;
      var staggerDurationBy = _props.staggerDurationBy;
      var delay = _props.delay;
      var staggerDelayBy = _props.staggerDelayBy;
      var easing = _props.easing;

delay += n * staggerDelayBy;
      duration += n * staggerDurationBy;

return props.map(function (prop) {
        return prop + ' ' + duration + 'ms ' + easing + ' ' + delay + 'ms';
      }).join(', ');
    }
  }, {
    key: 'triggerFinishHooks',
    value: function triggerFinishHooks(child, domNode) {
      var _this6 = this;

if (this.props.onFinish) this.props.onFinish(child, domNode);

// Reduce the number of children we need to animate by 1,
      // so that we can tell when all children have finished.
      this.remainingAnimations--;

if (this.remainingAnimations === 0) {
        // Reset our variables for the next iteration
        this.childrenToAnimate.elements = [];
        this.childrenToAnimate.domNodes = [];

// Remove any items from the DOM that have left, and reset `entering`.
        var nextChildren = this.state.children.filter(function (_ref4) {
          var leaving = _ref4.leaving;
          return !leaving;
        }).map(function (item) {
          return _extends({}, item, {
            entering: false
          });
        });

this.originalDomStyles = {};

this.setState({ children: nextChildren }, function () {
          if (typeof _this6.props.onFinishAll === 'function') {
            _this6.props.onFinishAll(_this6.childrenToAnimate.elements, _this6.childrenToAnimate.domNodes);
          }
        });
      }
    }
  }, {
    key: 'childrenWithRefs',
    value: function childrenWithRefs() {
      return this.state.children.map(function (child) {
        return _react2.default.cloneElement(child, { ref: child.key });
      });
    }
  }, {
    key: 'render',
    value: function render() {
      return _react2.default.createElement(this.props.typeName, this.props.delegated, this.childrenWithRefs());
    }
  }]);

return FlipMove;
}(_react.Component)) || _class;

exports.default = FlipMove;
module.exports = exports['default'];

/***/ }),
/* 1238 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
/**
 * React Flip Move | enterLeavePresets
 * (c) 2016-present Joshua Comeau
 *
 * This contains the master list of presets available for enter/leave animations,
 * along with the mapping between preset and styles.
 */

var enterPresets = exports.enterPresets = {
  'elevator': {
    from: { transform: 'scale(0)', opacity: 0 },
    to: { transform: '', opacity: '' }
  },
  'fade': {
    from: { opacity: 0 },
    to: { opacity: '' }
  },
  'accordionVertical': {
    from: { transform: 'scaleY(0)', transformOrigin: 'center top' },
    to: { transform: '', transformOrigin: 'center top' }
  },
  'accordionHorizontal': {
    from: { transform: 'scaleX(0)', transformOrigin: 'left center' },
    to: { transform: '', transformOrigin: 'left center' }
  },
  'none': false
};

var leavePresets = exports.leavePresets = {
  'elevator': {
    from: { transform: 'scale(1)', opacity: 1 },
    to: { transform: 'scale(0)', opacity: 0 }
  },
  'fade': {
    from: { opacity: 1 },
    to: { opacity: 0 }
  },
  'accordionVertical': {
    from: { transform: 'scaleY(1)', transformOrigin: 'center top' },
    to: { transform: 'scaleY(0)', transformOrigin: 'center top' }
  },
  'accordionHorizontal': {
    from: { transform: 'scaleX(1)', transformOrigin: 'left center' },
    to: { transform: 'scaleX(0)', transformOrigin: 'left center' }
  },
  'none': false
};

// Embarrassingly enough, v2.0 launched with typo'ed preset names.
// To avoid penning a new major version over something so inconsequential,
// we're supporting both spellings. In a future version, these alternatives
// may be deprecated.
enterPresets.accordianVertical = enterPresets.accordionVertical;
enterPresets.accordianHorizontal = enterPresets.accordionHorizontal;
leavePresets.accordianVertical = leavePresets.accordionVertical;
leavePresets.accordianHorizontal = leavePresets.accordionHorizontal;

var defaultPreset = exports.defaultPreset = 'elevator';
var disablePreset = exports.disablePreset = 'none';

/***/ }),
/* 1239 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/**
 * React Flip Move - Polyfills
 * (c) 2016-present Joshua Comeau
 */

if (!Array.prototype.find) {
  Array.prototype.find = function (predicate) {
    if (this === null) {
      throw new TypeError('Array.prototype.find called on null or undefined');
    }
    if (typeof predicate !== 'function') {
      throw new TypeError('predicate must be a function');
    }
    var list = Object(this);
    var length = list.length >>> 0;
    var thisArg = arguments[1];
    var value;

for (var i = 0; i < length; i++) {
      value = list[i];
      if (predicate.call(thisArg, value, i, list)) {
        return value;
      }
    }
    return undefined;
  };
}

/***/ }),
/* 1240 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _lodash = __webpack_require__(964);

var _lodash2 = _interopRequireDefault(_lodash);

var _helpers = __webpack_require__(491);

var _enterLeavePresets = __webpack_require__(1238);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function propConverter(ComposedComponent) {
  var _class, _temp;

return _temp = _class = function (_Component) {
    _inherits(Converter, _Component);

function Converter() {
      _classCallCheck(this, Converter);

return _possibleConstructorReturn(this, Object.getPrototypeOf(Converter).apply(this, arguments));
    }

_createClass(Converter, [{
      key: 'convertProps',
      value: function convertProps(props) {
        // Create a non-immutable working copy
        var workingProps = _extends({}, props);

// Do string-to-int conversion for all timing-related props
        var timingPropNames = ['duration', 'delay', 'staggerDurationBy', 'staggerDelayBy'];

timingPropNames.forEach(function (prop) {
          return workingProps[prop] = (0, _helpers.convertToInt)(workingProps[prop], prop);
        });

// Convert the children to a React.Children array.
        // This is to ensure we're always working with an array, and not
        // an only child. There's some weirdness with this.
        // See: https://github.com/facebook/react/pull/3650/files
        workingProps.children = _react2.default.Children.toArray(this.props.children);

// Convert an enterLeave preset to the real thing
        workingProps.enterAnimation = this.convertAnimationProp(workingProps.enterAnimation, _enterLeavePresets.enterPresets);
        workingProps.leaveAnimation = this.convertAnimationProp(workingProps.leaveAnimation, _enterLeavePresets.leavePresets);

// Accept `disableAnimations`, but add a deprecation warning
        if (typeof props.disableAnimations !== 'undefined') {
          console.warn("Warning, via react-flip-move: `disableAnimations` is deprecated. Please switch to use `disableAllAnimations`. This will become a silent error in future versions.");
          workingProps.disableAnimations = undefined;
          workingProps.disableAllAnimations = props.disableAnimations;
        }

// Gather any additional props; they will be delegated to the
        // ReactElement created.
        var primaryPropKeys = Object.keys(Converter.propTypes);
        var delegatedProps = (0, _lodash2.default)(this.props, primaryPropKeys);

// The FlipMove container element needs to have a non-static position.
        // We use `relative` by default, but it can be overridden by the user.
        // Now that we're delegating props, we need to merge this in.
        delegatedProps.style = _extends({
          position: 'relative'
        }, delegatedProps.style);

workingProps = (0, _lodash2.default)(workingProps, delegatedProps);
        workingProps.delegated = delegatedProps;

return workingProps;
      }
    }, {
      key: 'convertAnimationProp',
      value: function convertAnimationProp(animation, presets) {
        var newAnimation = undefined;

switch (typeof animation === 'undefined' ? 'undefined' : _typeof(animation)) {
          case 'boolean':
            // If it's true, we want to use the default preset.
            // If it's false, we want to use the 'none' preset.
            newAnimation = presets[animation ? _enterLeavePresets.defaultPreset : _enterLeavePresets.disablePreset];
            break;

case 'string':
            var presetKeys = Object.keys(presets);
            if (presetKeys.indexOf(animation) === -1) {
              console.warn('Warning, via react-flip-move: You supplied an invalid preset name of \'' + animation + '\'. The accepted values are: ' + presetKeys.join(', ') + '. Defaulting to ' + _enterLeavePresets.defaultPreset);
              newAnimation = presets[_enterLeavePresets.defaultPreset];
            } else {
              newAnimation = presets[animation];
            }
            break;

case 'object':
            // Ensure it has a 'from' and a 'to'.
            if (_typeof(animation.from) !== 'object' || _typeof(animation.to) !== 'object') {
              console.error("Error, via react-flip-move: Please provide `from` and `to` properties when supplying a custom animation object, or use a preset.");
            }

// TODO: More thorough validation? Ensure valid CSS properties?

newAnimation = animation;
            break;
        }

return newAnimation;
      }
    }, {
      key: 'render',
      value: function render() {
        return _react2.default.createElement(ComposedComponent, this.convertProps(this.props));
      }
    }]);

return Converter;
  }(_react.Component), _class.propTypes = {
    children: _react.PropTypes.oneOfType([_react.PropTypes.array, _react.PropTypes.object]).isRequired,
    easing: _react.PropTypes.string,
    duration: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.number]),
    delay: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.number]),
    staggerDurationBy: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.number]),
    staggerDelayBy: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.number]),
    onStart: _react.PropTypes.func,
    onFinish: _react.PropTypes.func,
    onStartAll: _react.PropTypes.func,
    onFinishAll: _react.PropTypes.func,
    typeName: _react.PropTypes.string,
    disableAllAnimations: _react.PropTypes.bool,
    enterAnimation: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.bool, _react.PropTypes.object]),
    leaveAnimation: _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.bool, _react.PropTypes.object]),
    getPosition: _react.PropTypes.func
  }, _class.defaultProps = {
    easing: 'ease-in-out',
    duration: 350,
    delay: 0,
    staggerDurationBy: 0,
    staggerDelayBy: 0,
    typeName: 'div',
    enterAnimation: _enterLeavePresets.defaultPreset,
    leaveAnimation: _enterLeavePresets.defaultPreset,
    getPosition: function getPosition(node) {
      return node.getBoundingClientRect();
    }
  }, _temp;
}

exports.default = propConverter;
module.exports = exports['default'];

/***/ }),
/* 1241 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/** @license React v16.13.1
 * react-is.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

if (process.env.NODE_ENV !== "production") {
  (function() {
'use strict';

// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var hasSymbol = typeof Symbol === 'function' && Symbol.for;
var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
// (unstable) APIs that have been removed. Can we remove the symbols?

var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;

function isValidElementType(type) {
  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
}

function typeOf(object) {
  if (typeof object === 'object' && object !== null) {
    var $$typeof = object.$$typeof;

switch ($$typeof) {
      case REACT_ELEMENT_TYPE:
        var type = object.type;

switch (type) {
          case REACT_ASYNC_MODE_TYPE:
          case REACT_CONCURRENT_MODE_TYPE:
          case REACT_FRAGMENT_TYPE:
          case REACT_PROFILER_TYPE:
          case REACT_STRICT_MODE_TYPE:
          case REACT_SUSPENSE_TYPE:
            return type;

default:
            var $$typeofType = type && type.$$typeof;

switch ($$typeofType) {
              case REACT_CONTEXT_TYPE:
              case REACT_FORWARD_REF_TYPE:
              case REACT_LAZY_TYPE:
              case REACT_MEMO_TYPE:
              case REACT_PROVIDER_TYPE:
                return $$typeofType;

default:
                return $$typeof;
            }

}

case REACT_PORTAL_TYPE:
        return $$typeof;
    }
  }

return undefined;
} // AsyncMode is deprecated along with isAsyncMode

var AsyncMode = REACT_ASYNC_MODE_TYPE;
var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
var ContextConsumer = REACT_CONTEXT_TYPE;
var ContextProvider = REACT_PROVIDER_TYPE;
var Element = REACT_ELEMENT_TYPE;
var ForwardRef = REACT_FORWARD_REF_TYPE;
var Fragment = REACT_FRAGMENT_TYPE;
var Lazy = REACT_LAZY_TYPE;
var Memo = REACT_MEMO_TYPE;
var Portal = REACT_PORTAL_TYPE;
var Profiler = REACT_PROFILER_TYPE;
var StrictMode = REACT_STRICT_MODE_TYPE;
var Suspense = REACT_SUSPENSE_TYPE;
var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated

function isAsyncMode(object) {
  {
    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint

console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
    }
  }

return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
}
function isConcurrentMode(object) {
  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
}
function isContextConsumer(object) {
  return typeOf(object) === REACT_CONTEXT_TYPE;
}
function isContextProvider(object) {
  return typeOf(object) === REACT_PROVIDER_TYPE;
}
function isElement(object) {
  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
function isForwardRef(object) {
  return typeOf(object) === REACT_FORWARD_REF_TYPE;
}
function isFragment(object) {
  return typeOf(object) === REACT_FRAGMENT_TYPE;
}
function isLazy(object) {
  return typeOf(object) === REACT_LAZY_TYPE;
}
function isMemo(object) {
  return typeOf(object) === REACT_MEMO_TYPE;
}
function isPortal(object) {
  return typeOf(object) === REACT_PORTAL_TYPE;
}
function isProfiler(object) {
  return typeOf(object) === REACT_PROFILER_TYPE;
}
function isStrictMode(object) {
  return typeOf(object) === REACT_STRICT_MODE_TYPE;
}
function isSuspense(object) {
  return typeOf(object) === REACT_SUSPENSE_TYPE;
}

exports.AsyncMode = AsyncMode;
exports.ConcurrentMode = ConcurrentMode;
exports.ContextConsumer = ContextConsumer;
exports.ContextProvider = ContextProvider;
exports.Element = Element;
exports.ForwardRef = ForwardRef;
exports.Fragment = Fragment;
exports.Lazy = Lazy;
exports.Memo = Memo;
exports.Portal = Portal;
exports.Profiler = Profiler;
exports.StrictMode = StrictMode;
exports.Suspense = Suspense;
exports.isAsyncMode = isAsyncMode;
exports.isConcurrentMode = isConcurrentMode;
exports.isContextConsumer = isContextConsumer;
exports.isContextProvider = isContextProvider;
exports.isElement = isElement;
exports.isForwardRef = isForwardRef;
exports.isFragment = isFragment;
exports.isLazy = isLazy;
exports.isMemo = isMemo;
exports.isPortal = isPortal;
exports.isProfiler = isProfiler;
exports.isStrictMode = isStrictMode;
exports.isSuspense = isSuspense;
exports.isValidElementType = isValidElementType;
exports.typeOf = typeOf;
  })();
}

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1242 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/** @license React v16.13.1
 * react-is.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/***/ }),
/* 1243 */
/***/ (function(module, exports, __webpack_require__) {

var isBrowser = typeof window !== 'undefined';
var Masonry = isBrowser ? window.Masonry || __webpack_require__(1100) : null;
var imagesloaded = isBrowser ? __webpack_require__(954) : null;
var assign = __webpack_require__(1073);
var elementResizeDetectorMaker = __webpack_require__(871);
var debounce = __webpack_require__(291);
var omit = __webpack_require__(1091);
var PropTypes = __webpack_require__(6);
var React = __webpack_require__(0);
var createReactClass = __webpack_require__(838);

var propTypes = {
  enableResizableChildren: PropTypes.bool,
  disableImagesLoaded: PropTypes.bool,
  onImagesLoaded: PropTypes.func,
  updateOnEachImageLoad: PropTypes.bool,
  options: PropTypes.object,
  imagesLoadedOptions: PropTypes.object,
  elementType: PropTypes.string,
  onLayoutComplete: PropTypes.func,
  onRemoveComplete: PropTypes.func
};

var MasonryComponent = createReactClass({
  masonry: false,
  erd: undefined,
  latestKnownDomChildren: [],
  displayName: 'MasonryComponent',
  imagesLoadedCancelRef: undefined,
  propTypes: propTypes,

getDefaultProps: function() {
    return {
      enableResizableChildren: false,
      disableImagesLoaded: false,
      updateOnEachImageLoad: false,
      options: {},
      imagesLoadedOptions: {},
      className: '',
      elementType: 'div',
      onLayoutComplete: function() {
      },
      onRemoveComplete: function() {
      }
    };
  },

initializeMasonry: function(force) {
    if (!this.masonry || force) {
      this.masonry = new Masonry(
        this.masonryContainer,
        this.props.options
      );

if (this.props.onLayoutComplete) {
        this.masonry.on('layoutComplete', this.props.onLayoutComplete);
      }

if (this.props.onRemoveComplete) {
        this.masonry.on('removeComplete', this.props.onRemoveComplete);
      }

this.latestKnownDomChildren = this.getCurrentDomChildren();
    }
  },

getCurrentDomChildren: function() {
    var node = this.masonryContainer;
    var children = this.props.options.itemSelector ? node.querySelectorAll(this.props.options.itemSelector) : node.children;
    return Array.prototype.slice.call(children);
  },

diffDomChildren: function() {
    var forceItemReload = false;

var knownChildrenStillAttached = this.latestKnownDomChildren.filter(function(element) {
      /*
       * take only elements attached to DOM
       * (aka the parent is the masonry container, not null)
       * otherwise masonry would try to "remove it" again from the DOM
       */
      return !!element.parentNode;
    });

/*
     * If not all known children are attached to the dom - we have no other way of notifying
     * masonry to remove the ones not still attached besides invoking a complete item reload.
     * basically all the rest of the code below does not matter in that case.
     */
    if (knownChildrenStillAttached.length !== this.latestKnownDomChildren.length) {
      forceItemReload = true;
    }

var currentDomChildren = this.getCurrentDomChildren();

/*
     * Since we are looking for a known child which is also attached to the dom AND
     * not attached to the dom at the same time - this would *always* produce an empty array.
     */
    var removed = knownChildrenStillAttached.filter(function(attachedKnownChild) {
      return !~currentDomChildren.indexOf(attachedKnownChild);
    });

/*
     * This would get any children which are attached to the dom but are *unkown* to us
     * from previous renders
     */
    var newDomChildren = currentDomChildren.filter(function(currentChild) {
      return !~knownChildrenStillAttached.indexOf(currentChild);
    });

var beginningIndex = 0;

// get everything added to the beginning of the DOMNode list
    var prepended = newDomChildren.filter(function(newChild) {
      var prepend = (beginningIndex === currentDomChildren.indexOf(newChild));

if (prepend) {
        // increase the index
        beginningIndex++;
      }

return prepend;
    });

// we assume that everything else is appended
    var appended = newDomChildren.filter(function(el) {
      return prepended.indexOf(el) === -1;
    });

/*
     * otherwise we reverse it because so we're going through the list picking off the items that
     * have been added at the end of the list. this complex logic is preserved in case it needs to be
     * invoked
     *
     * var endingIndex = currentDomChildren.length - 1;
     *
     * newDomChildren.reverse().filter(function(newChild, i){
     *     var append = endingIndex == currentDomChildren.indexOf(newChild);
     *
     *     if (append) {
     *         endingIndex--;
     *     }
     *
     *     return append;
     * });
     */

// get everything added to the end of the DOMNode list
    var moved = [];

/*
     * This would always be true (see above about the lofic for "removed")
     */
    if (removed.length === 0) {
      /*
       * 'moved' will contain some random elements (if any) since the "knownChildrenStillAttached" is a filter
       * of the "known" children which are still attached - All indexes could basically change. (for example
       * if the first element is not attached)
       * Don't trust this array.
       */
      moved = knownChildrenStillAttached.filter(function(child, index) {
        return index !== currentDomChildren.indexOf(child);
      });
    }

this.latestKnownDomChildren = currentDomChildren;

return {
      old: knownChildrenStillAttached, // Not used
      new: currentDomChildren, // Not used
      removed: removed,
      appended: appended,
      prepended: prepended,
      moved: moved,
      forceItemReload: forceItemReload
    };
  },

performLayout: function() {
    var diff = this.diffDomChildren();
    var reloadItems = diff.forceItemReload || diff.moved.length > 0;

// Would never be true. (see comments of 'diffDomChildren' about 'removed')
    if (diff.removed.length > 0) {
      if (this.props.enableResizableChildren) {
        diff.removed.forEach(this.erd.removeAllListeners, this.erd);
      }
      this.masonry.remove(diff.removed);
      reloadItems = true;
    }

if (diff.appended.length > 0) {
      this.masonry.appended(diff.appended);

if (diff.prepended.length === 0) {
        reloadItems = true;
      }

if (this.props.enableResizableChildren) {
        diff.appended.forEach(this.listenToElementResize, this);
      }
    }

if (diff.prepended.length > 0) {
      this.masonry.prepended(diff.prepended);

if (this.props.enableResizableChildren) {
        diff.prepended.forEach(this.listenToElementResize, this);
      }
    }

if (reloadItems) {
      this.masonry.reloadItems();
    }

this.masonry.layout();
  },

derefImagesLoaded: function() {
    this.imagesLoadedCancelRef();
    this.imagesLoadedCancelRef = undefined;
  },

imagesLoaded: function() {
    if (this.props.disableImagesLoaded) {
      return;
    }

if (this.imagesLoadedCancelRef) {
      this.derefImagesLoaded();
    }

var event = this.props.updateOnEachImageLoad ? 'progress' : 'always';
    var handler = debounce(
      function(instance) {
        if (this.props.onImagesLoaded) {
          this.props.onImagesLoaded(instance);
        }
        this.masonry.layout();
      }.bind(this), 100);

var imgLoad = imagesloaded(this.masonryContainer, this.props.imagesLoadedOptions).on(event, handler);

this.imagesLoadedCancelRef = function() {
      imgLoad.off(event, handler);
      handler.cancel();
    };
  },

initializeResizableChildren: function() {
    if (!this.props.enableResizableChildren) {
      return;
    }

this.erd = elementResizeDetectorMaker({
      strategy: 'scroll'
    });

this.latestKnownDomChildren.forEach(this.listenToElementResize, this);
  },

listenToElementResize: function(el) {
    this.erd.listenTo(el, function() {
      this.masonry.layout()
    }.bind(this))
  },

destroyErd: function() {
    if (this.erd) {
      this.latestKnownDomChildren.forEach(this.erd.uninstall, this.erd);
    }
  },

componentDidMount: function() {
    this.initializeMasonry();
    this.initializeResizableChildren();
    this.imagesLoaded();
  },

componentDidUpdate: function() {
    this.performLayout();
    this.imagesLoaded();
  },

componentWillUnmount: function() {
    this.destroyErd();

// unregister events
    if (this.props.onLayoutComplete) {
      this.masonry.off('layoutComplete', this.props.onLayoutComplete);
    }

if (this.props.onRemoveComplete) {
      this.masonry.off('removeComplete', this.props.onRemoveComplete);
    }

if (this.imagesLoadedCancelRef) {
      this.derefImagesLoaded();
    }
    this.masonry.destroy();
  },
  
  setRef: function(n) {
    this.masonryContainer = n;
  },

render: function() {
    var props = omit(this.props, Object.keys(propTypes));
    return React.createElement(this.props.elementType, assign({}, props, {ref: this.setRef}), this.props.children);
  }
});

module.exports = MasonryComponent;
module.exports.default = MasonryComponent;

/***/ }),
/* 1244 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

var _InternalPropTypes = __webpack_require__(88);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A mixin that adds the "history" instance variable to components.
 */
var History = {

contextTypes: {
    history: _InternalPropTypes.history
  },

componentWillMount: function componentWillMount() {
    process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, 'the `History` mixin is deprecated, please access `context.router` with your own `contextTypes`. http://tiny.cc/router-historymixin') : void 0;
    this.history = this.context.history;
  }
};

exports.default = History;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1245 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _Link = __webpack_require__(493);

var _Link2 = _interopRequireDefault(_Link);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * An <IndexLink> is used to link to an <IndexRoute>.
 */
var IndexLink = _react2.default.createClass({
  displayName: 'IndexLink',
  render: function render() {
    return _react2.default.createElement(_Link2.default, _extends({}, this.props, { onlyActiveOnIndex: true }));
  }
});

exports.default = IndexLink;
module.exports = exports['default'];

/***/ }),
/* 1246 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _Redirect = __webpack_require__(494);

var _Redirect2 = _interopRequireDefault(_Redirect);

var _InternalPropTypes = __webpack_require__(88);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _React$PropTypes = _react2.default.PropTypes;
var string = _React$PropTypes.string;
var object = _React$PropTypes.object;

/**
 * An <IndexRedirect> is used to redirect from an indexRoute.
 */

var IndexRedirect = _react2.default.createClass({
  displayName: 'IndexRedirect',

statics: {
    createRouteFromReactElement: function createRouteFromReactElement(element, parentRoute) {
      /* istanbul ignore else: sanity check */
      if (parentRoute) {
        parentRoute.indexRoute = _Redirect2.default.createRouteFromReactElement(element);
      } else {
        process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, 'An <IndexRedirect> does not make sense at the root of your route config') : void 0;
      }
    }
  },

propTypes: {
    to: string.isRequired,
    query: object,
    state: object,
    onEnter: _InternalPropTypes.falsy,
    children: _InternalPropTypes.falsy
  },

/* istanbul ignore next: sanity check */
  render: function render() {
     true ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, '<IndexRedirect> elements are for router configuration only and should not be rendered') : (0, _invariant2.default)(false) : void 0;
  }
});

exports.default = IndexRedirect;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1247 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _RouteUtils = __webpack_require__(75);

var _InternalPropTypes = __webpack_require__(88);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var func = _react2.default.PropTypes.func;

/**
 * An <IndexRoute> is used to specify its parent's <Route indexRoute> in
 * a JSX route config.
 */

var IndexRoute = _react2.default.createClass({
  displayName: 'IndexRoute',

statics: {
    createRouteFromReactElement: function createRouteFromReactElement(element, parentRoute) {
      /* istanbul ignore else: sanity check */
      if (parentRoute) {
        parentRoute.indexRoute = (0, _RouteUtils.createRouteFromReactElement)(element);
      } else {
        process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, 'An <IndexRoute> does not make sense at the root of your route config') : void 0;
      }
    }
  },

propTypes: {
    path: _InternalPropTypes.falsy,
    component: _InternalPropTypes.component,
    components: _InternalPropTypes.components,
    getComponent: func,
    getComponents: func
  },

/* istanbul ignore next: sanity check */
  render: function render() {
     true ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, '<IndexRoute> elements are for router configuration only and should not be rendered') : (0, _invariant2.default)(false) : void 0;
  }
});

exports.default = IndexRoute;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1248 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var object = _react2.default.PropTypes.object;

/**
 * The Lifecycle mixin adds the routerWillLeave lifecycle method to a
 * component that may be used to cancel a transition or prompt the user
 * for confirmation.
 *
 * On standard transitions, routerWillLeave receives a single argument: the
 * location we're transitioning to. To cancel the transition, return false.
 * To prompt the user for confirmation, return a prompt message (string).
 *
 * During the beforeunload event (assuming you're using the useBeforeUnload
 * history enhancer), routerWillLeave does not receive a location object
 * because it isn't possible for us to know the location we're transitioning
 * to. In this case routerWillLeave must return a prompt message to prevent
 * the user from closing the window/tab.
 */

var Lifecycle = {

contextTypes: {
    history: object.isRequired,
    // Nested children receive the route as context, either
    // set by the route component using the RouteContext mixin
    // or by some other ancestor.
    route: object
  },

propTypes: {
    // Route components receive the route object as a prop.
    route: object
  },

componentDidMount: function componentDidMount() {
    process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, 'the `Lifecycle` mixin is deprecated, please use `context.router.setRouteLeaveHook(route, hook)`. http://tiny.cc/router-lifecyclemixin') : void 0;
    !this.routerWillLeave ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, 'The Lifecycle mixin requires you to define a routerWillLeave method') : (0, _invariant2.default)(false) : void 0;

var route = this.props.route || this.context.route;

!route ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, 'The Lifecycle mixin must be used on either a) a <Route component> or ' + 'b) a descendant of a <Route component> that uses the RouteContext mixin') : (0, _invariant2.default)(false) : void 0;

this._unlistenBeforeLeavingRoute = this.context.history.listenBeforeLeavingRoute(route, this.routerWillLeave);
  },
  componentWillUnmount: function componentWillUnmount() {
    if (this._unlistenBeforeLeavingRoute) this._unlistenBeforeLeavingRoute();
  }
};

exports.default = Lifecycle;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1249 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _RouteUtils = __webpack_require__(75);

var _InternalPropTypes = __webpack_require__(88);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _React$PropTypes = _react2.default.PropTypes;
var string = _React$PropTypes.string;
var func = _React$PropTypes.func;

/**
 * A <Route> is used to declare which components are rendered to the
 * page when the URL matches a given pattern.
 *
 * Routes are arranged in a nested tree structure. When a new URL is
 * requested, the tree is searched depth-first to find a route whose
 * path matches the URL.  When one is found, all routes in the tree
 * that lead to it are considered "active" and their components are
 * rendered into the DOM, nested in the same order as in the tree.
 */

var Route = _react2.default.createClass({
  displayName: 'Route',

statics: {
    createRouteFromReactElement: _RouteUtils.createRouteFromReactElement
  },

propTypes: {
    path: string,
    component: _InternalPropTypes.component,
    components: _InternalPropTypes.components,
    getComponent: func,
    getComponents: func
  },

/* istanbul ignore next: sanity check */
  render: function render() {
     true ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, '<Route> elements are for router configuration only and should not be rendered') : (0, _invariant2.default)(false) : void 0;
  }
});

exports.default = Route;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1250 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var object = _react2.default.PropTypes.object;

/**
 * The RouteContext mixin provides a convenient way for route
 * components to set the route in context. This is needed for
 * routes that render elements that want to use the Lifecycle
 * mixin to prevent transitions.
 */

var RouteContext = {

propTypes: {
    route: object.isRequired
  },

childContextTypes: {
    route: object.isRequired
  },

getChildContext: function getChildContext() {
    return {
      route: this.props.route
    };
  },
  componentWillMount: function componentWillMount() {
    process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, 'The `RouteContext` mixin is deprecated. You can provide `this.props.route` on context with your own `contextTypes`. http://tiny.cc/router-routecontextmixin') : void 0;
  }
};

exports.default = RouteContext;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1251 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _createHashHistory = __webpack_require__(417);

var _createHashHistory2 = _interopRequireDefault(_createHashHistory);

var _useQueries = __webpack_require__(170);

var _useQueries2 = _interopRequireDefault(_useQueries);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _createTransitionManager = __webpack_require__(309);

var _createTransitionManager2 = _interopRequireDefault(_createTransitionManager);

var _InternalPropTypes = __webpack_require__(88);

var _RouterContext = __webpack_require__(187);

var _RouterContext2 = _interopRequireDefault(_RouterContext);

var _RouteUtils = __webpack_require__(75);

var _RouterUtils = __webpack_require__(495);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function isDeprecatedHistory(history) {
  return !history || !history.__v2_compatible__;
}

/* istanbul ignore next: sanity check */
function isUnsupportedHistory(history) {
  // v3 histories expose getCurrentLocation, but aren't currently supported.
  return history && history.getCurrentLocation;
}

var _React$PropTypes = _react2.default.PropTypes;
var func = _React$PropTypes.func;
var object = _React$PropTypes.object;

/**
 * A <Router> is a high-level API for automatically setting up
 * a router that renders a <RouterContext> with all the props
 * it needs each time the URL changes.
 */

var Router = _react2.default.createClass({
  displayName: 'Router',

propTypes: {
    history: object,
    children: _InternalPropTypes.routes,
    routes: _InternalPropTypes.routes, // alias for children
    render: func,
    createElement: func,
    onError: func,
    onUpdate: func,

// Deprecated:
    parseQueryString: func,
    stringifyQuery: func,

// PRIVATE: For client-side rehydration of server match.
    matchContext: object
  },

getDefaultProps: function getDefaultProps() {
    return {
      render: function render(props) {
        return _react2.default.createElement(_RouterContext2.default, props);
      }
    };
  },
  getInitialState: function getInitialState() {
    return {
      location: null,
      routes: null,
      params: null,
      components: null
    };
  },
  handleError: function handleError(error) {
    if (this.props.onError) {
      this.props.onError.call(this, error);
    } else {
      // Throw errors by default so we don't silently swallow them!
      throw error; // This error probably occurred in getChildRoutes or getComponents.
    }
  },
  componentWillMount: function componentWillMount() {
    var _this = this;

var _props = this.props;
    var parseQueryString = _props.parseQueryString;
    var stringifyQuery = _props.stringifyQuery;

process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(!(parseQueryString || stringifyQuery), '`parseQueryString` and `stringifyQuery` are deprecated. Please create a custom history. http://tiny.cc/router-customquerystring') : void 0;

var _createRouterObjects = this.createRouterObjects();

var history = _createRouterObjects.history;
    var transitionManager = _createRouterObjects.transitionManager;
    var router = _createRouterObjects.router;

this._unlisten = transitionManager.listen(function (error, state) {
      if (error) {
        _this.handleError(error);
      } else {
        _this.setState(state, _this.props.onUpdate);
      }
    });

this.history = history;
    this.router = router;
  },
  createRouterObjects: function createRouterObjects() {
    var matchContext = this.props.matchContext;

if (matchContext) {
      return matchContext;
    }

var history = this.props.history;
    var _props2 = this.props;
    var routes = _props2.routes;
    var children = _props2.children;

!!isUnsupportedHistory(history) ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, 'You have provided a history object created with history v3.x. ' + 'This version of React Router is not compatible with v3 history ' + 'objects. Please use history v2.x instead.') : (0, _invariant2.default)(false) : void 0;

if (isDeprecatedHistory(history)) {
      history = this.wrapDeprecatedHistory(history);
    }

var transitionManager = (0, _createTransitionManager2.default)(history, (0, _RouteUtils.createRoutes)(routes || children));
    var router = (0, _RouterUtils.createRouterObject)(history, transitionManager);
    var routingHistory = (0, _RouterUtils.createRoutingHistory)(history, transitionManager);

return { history: routingHistory, transitionManager: transitionManager, router: router };
  },
  wrapDeprecatedHistory: function wrapDeprecatedHistory(history) {
    var _props3 = this.props;
    var parseQueryString = _props3.parseQueryString;
    var stringifyQuery = _props3.stringifyQuery;

return (0, _useQueries2.default)(createHistory)({ parseQueryString: parseQueryString, stringifyQuery: stringifyQuery });
  },

/* istanbul ignore next: sanity check */
  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
    process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(nextProps.history === this.props.history, 'You cannot change <Router history>; it will be ignored') : void 0;

process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)((nextProps.routes || nextProps.children) === (this.props.routes || this.props.children), 'You cannot change <Router routes>; it will be ignored') : void 0;
  },
  componentWillUnmount: function componentWillUnmount() {
    if (this._unlisten) this._unlisten();
  },
  render: function render() {
    var _state = this.state;
    var location = _state.location;
    var routes = _state.routes;
    var params = _state.params;
    var components = _state.components;
    var _props4 = this.props;
    var createElement = _props4.createElement;
    var render = _props4.render;

var props = _objectWithoutProperties(_props4, ['createElement', 'render']);

if (location == null) return null; // Async match

// Only forward non-Router-specific props to routing context, as those are
    // the only ones that might be custom routing context props.
    Object.keys(Router.propTypes).forEach(function (propType) {
      return delete props[propType];
    });

return render(_extends({}, props, {
      history: this.history,
      router: this.router,
      location: location,
      routes: routes,
      params: params,
      components: components,
      createElement: createElement
    }));
  }
});

exports.default = Router;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1252 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _RouterContext = __webpack_require__(187);

var _RouterContext2 = _interopRequireDefault(_RouterContext);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = RoutingContext;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1253 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.runEnterHooks = runEnterHooks;
exports.runChangeHooks = runChangeHooks;
exports.runLeaveHooks = runLeaveHooks;

var _AsyncUtils = __webpack_require__(307);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function createTransitionHook(hook, route, asyncArity) {
  return function () {
    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

hook.apply(route, args);

if (hook.length < asyncArity) {
      var callback = args[args.length - 1];
      // Assume hook executes synchronously and
      // automatically call the callback.
      callback();
    }
  };
}

function getEnterHooks(routes) {
  return routes.reduce(function (hooks, route) {
    if (route.onEnter) hooks.push(createTransitionHook(route.onEnter, route, 3));

return hooks;
  }, []);
}

function getChangeHooks(routes) {
  return routes.reduce(function (hooks, route) {
    if (route.onChange) hooks.push(createTransitionHook(route.onChange, route, 4));
    return hooks;
  }, []);
}

function runTransitionHooks(length, iter, callback) {
  if (!length) {
    callback();
    return;
  }

var redirectInfo = void 0;
  function replace(location, deprecatedPathname, deprecatedQuery) {
    if (deprecatedPathname) {
      process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, '`replaceState(state, pathname, query) is deprecated; use `replace(location)` with a location descriptor instead. http://tiny.cc/router-isActivedeprecated') : void 0;
      redirectInfo = {
        pathname: deprecatedPathname,
        query: deprecatedQuery,
        state: location
      };

return;
    }

redirectInfo = location;
  }

(0, _AsyncUtils.loopAsync)(length, function (index, next, done) {
    iter(index, replace, function (error) {
      if (error || redirectInfo) {
        done(error, redirectInfo); // No need to continue.
      } else {
        next();
      }
    });
  }, callback);
}

/**
 * Runs all onEnter hooks in the given array of routes in order
 * with onEnter(nextState, replace, callback) and calls
 * callback(error, redirectInfo) when finished. The first hook
 * to use replace short-circuits the loop.
 *
 * If a hook needs to run asynchronously, it may use the callback
 * function. However, doing so will cause the transition to pause,
 * which could lead to a non-responsive UI if the hook is slow.
 */
function runEnterHooks(routes, nextState, callback) {
  var hooks = getEnterHooks(routes);
  return runTransitionHooks(hooks.length, function (index, replace, next) {
    hooks[index](nextState, replace, next);
  }, callback);
}

/**
 * Runs all onChange hooks in the given array of routes in order
 * with onChange(prevState, nextState, replace, callback) and calls
 * callback(error, redirectInfo) when finished. The first hook
 * to use replace short-circuits the loop.
 *
 * If a hook needs to run asynchronously, it may use the callback
 * function. However, doing so will cause the transition to pause,
 * which could lead to a non-responsive UI if the hook is slow.
 */
function runChangeHooks(routes, state, nextState, callback) {
  var hooks = getChangeHooks(routes);
  return runTransitionHooks(hooks.length, function (index, replace, next) {
    hooks[index](state, nextState, replace, next);
  }, callback);
}

/**
 * Runs all onLeave hooks in the given array of routes in order.
 */
function runLeaveHooks(routes, prevState) {
  for (var i = 0, len = routes.length; i < len; ++i) {
    if (routes[i].onLeave) routes[i].onLeave.call(routes[i], prevState);
  }
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1254 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _RouterContext = __webpack_require__(187);

var _RouterContext2 = _interopRequireDefault(_RouterContext);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = function () {
  for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {
    middlewares[_key] = arguments[_key];
  }

if (process.env.NODE_ENV !== 'production') {
    middlewares.forEach(function (middleware, index) {
      process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(middleware.renderRouterContext || middleware.renderRouteComponent, 'The middleware specified at index ' + index + ' does not appear to be ' + 'a valid React Router middleware.') : void 0;
    });
  }

var withContext = middlewares.map(function (middleware) {
    return middleware.renderRouterContext;
  }).filter(Boolean);
  var withComponent = middlewares.map(function (middleware) {
    return middleware.renderRouteComponent;
  }).filter(Boolean);

return function (renderProps) {
    return withContext.reduceRight(function (previous, renderRouterContext) {
      return renderRouterContext(previous, renderProps);
    }, _react2.default.createElement(_RouterContext2.default, _extends({}, renderProps, {
      createElement: makeCreateElement(renderProps.createElement)
    })));
  };
};

module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1255 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _createBrowserHistory = __webpack_require__(949);

var _createBrowserHistory2 = _interopRequireDefault(_createBrowserHistory);

var _createRouterHistory = __webpack_require__(497);

var _createRouterHistory2 = _interopRequireDefault(_createRouterHistory);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = (0, _createRouterHistory2.default)(_createBrowserHistory2.default);
module.exports = exports['default'];

/***/ }),
/* 1256 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _PatternUtils = __webpack_require__(112);

function routeParamsChanged(route, prevState, nextState) {
  if (!route.path) return false;

var paramNames = (0, _PatternUtils.getParamNames)(route.path);

return paramNames.some(function (paramName) {
    return prevState.params[paramName] !== nextState.params[paramName];
  });
}

/**
 * Returns an object of { leaveRoutes, changeRoutes, enterRoutes } determined by
 * the change from prevState to nextState. We leave routes if either
 * 1) they are not in the next state or 2) they are in the next state
 * but their params have changed (i.e. /users/123 => /users/456).
 *
 * leaveRoutes are ordered starting at the leaf route of the tree
 * we're leaving up to the common parent route. enterRoutes are ordered
 * from the top of the tree we're entering down to the leaf route.
 *
 * changeRoutes are any routes that didn't leave or enter during
 * the transition.
 */
function computeChangedRoutes(prevState, nextState) {
  var prevRoutes = prevState && prevState.routes;
  var nextRoutes = nextState.routes;

// onLeave hooks start at the leaf route.
      leaveRoutes.reverse();

enterRoutes = [];
      changeRoutes = [];

nextRoutes.forEach(function (route) {
        var isNew = prevRoutes.indexOf(route) === -1;
        var paramsChanged = leaveRoutes.indexOf(route) !== -1;

if (isNew || paramsChanged) enterRoutes.push(route);else changeRoutes.push(route);
      });
    })();
  } else {
    leaveRoutes = [];
    changeRoutes = [];
    enterRoutes = nextRoutes;
  }

return {
    leaveRoutes: leaveRoutes,
    changeRoutes: changeRoutes,
    enterRoutes: enterRoutes
  };
}

exports.default = computeChangedRoutes;
module.exports = exports['default'];

/***/ }),
/* 1257 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _AsyncUtils = __webpack_require__(307);

var _makeStateWithLocation = __webpack_require__(498);

var _makeStateWithLocation2 = _interopRequireDefault(_makeStateWithLocation);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function getComponentsForRoute(nextState, route, callback) {
  if (route.component || route.components) {
    callback(null, route.component || route.components);
    return;
  }

var getComponent = route.getComponent || route.getComponents;
  if (!getComponent) {
    callback();
    return;
  }

var location = nextState.location;

var nextStateWithLocation = (0, _makeStateWithLocation2.default)(nextState, location);

getComponent.call(route, nextStateWithLocation, callback);
}

/**
 * Asynchronously fetches all components needed for the given router
 * state and calls callback(error, components) when finished.
 *
 * Note: This operation may finish synchronously if no routes have an
 * asynchronous getComponents method.
 */
function getComponents(nextState, callback) {
  (0, _AsyncUtils.mapAsync)(nextState.routes, function (route, index, callback) {
    getComponentsForRoute(nextState, route, callback);
  }, callback);
}

exports.default = getComponents;
module.exports = exports['default'];

/***/ }),
/* 1258 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _PatternUtils = __webpack_require__(112);

/**
 * Extracts an object of params the given route cares about from
 * the given params object.
 */
function getRouteParams(route, params) {
  var routeParams = {};

if (!route.path) return routeParams;

(0, _PatternUtils.getParamNames)(route.path).forEach(function (p) {
    if (Object.prototype.hasOwnProperty.call(params, p)) {
      routeParams[p] = params[p];
    }
  });

return routeParams;
}

exports.default = getRouteParams;
module.exports = exports['default'];

/***/ }),
/* 1259 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _createHashHistory = __webpack_require__(417);

var _createHashHistory2 = _interopRequireDefault(_createHashHistory);

var _createRouterHistory = __webpack_require__(497);

var _createRouterHistory2 = _interopRequireDefault(_createRouterHistory);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = (0, _createRouterHistory2.default)(_createHashHistory2.default);
module.exports = exports['default'];

/***/ }),
/* 1260 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

exports.default = isActive;

var _PatternUtils = __webpack_require__(112);

function deepEqual(a, b) {
  if (a == b) return true;

if (a == null || b == null) return false;

if (Array.isArray(a)) {
    return Array.isArray(b) && a.length === b.length && a.every(function (item, index) {
      return deepEqual(item, b[index]);
    });
  }

if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) === 'object') {
    for (var p in a) {
      if (!Object.prototype.hasOwnProperty.call(a, p)) {
        continue;
      }

if (a[p] === undefined) {
        if (b[p] !== undefined) {
          return false;
        }
      } else if (!Object.prototype.hasOwnProperty.call(b, p)) {
        return false;
      } else if (!deepEqual(a[p], b[p])) {
        return false;
      }
    }

return true;
  }

return String(a) === String(b);
}

/**
 * Returns true if the current pathname matches the supplied one, net of
 * leading and trailing slash normalization. This is sufficient for an
 * indexOnly route match.
 */
function pathIsActive(pathname, currentPathname) {
  // Normalize leading slash for consistency. Leading slash on pathname has
  // already been normalized in isActive. See caveat there.
  if (currentPathname.charAt(0) !== '/') {
    currentPathname = '/' + currentPathname;
  }

// Normalize the end of both path names too. Maybe `/foo/` shouldn't show
  // `/foo` as active, but in this case, we would already have failed the
  // match.
  if (pathname.charAt(pathname.length - 1) !== '/') {
    pathname += '/';
  }
  if (currentPathname.charAt(currentPathname.length - 1) !== '/') {
    currentPathname += '/';
  }

return currentPathname === pathname;
}

/**
 * Returns true if the given pathname matches the active routes and params.
 */
function routeIsActive(pathname, routes, params) {
  var remainingPathname = pathname,
      paramNames = [],
      paramValues = [];

// for...of would work here but it's probably slower post-transpilation.
  for (var i = 0, len = routes.length; i < len; ++i) {
    var route = routes[i];
    var pattern = route.path || '';

if (pattern.charAt(0) === '/') {
      remainingPathname = pathname;
      paramNames = [];
      paramValues = [];
    }

if (remainingPathname !== null && pattern) {
      var matched = (0, _PatternUtils.matchPattern)(pattern, remainingPathname);
      if (matched) {
        remainingPathname = matched.remainingPathname;
        paramNames = [].concat(paramNames, matched.paramNames);
        paramValues = [].concat(paramValues, matched.paramValues);
      } else {
        remainingPathname = null;
      }

if (remainingPathname === '') {
        // We have an exact match on the route. Just check that all the params
        // match.
        // FIXME: This doesn't work on repeated params.
        return paramNames.every(function (paramName, index) {
          return String(paramValues[index]) === String(params[paramName]);
        });
      }
    }
  }

return false;
}

/**
 * Returns true if all key/value pairs in the given query are
 * currently active.
 */
function queryIsActive(query, activeQuery) {
  if (activeQuery == null) return query == null;

if (query == null) return true;

return deepEqual(query, activeQuery);
}

/**
 * Returns true if a <Link> to the given pathname/query combination is
 * currently active.
 */
function isActive(_ref, indexOnly, currentLocation, routes, params) {
  var pathname = _ref.pathname;
  var query = _ref.query;

if (currentLocation == null) return false;

// TODO: This is a bit ugly. It keeps around support for treating pathnames
  // without preceding slashes as absolute paths, but possibly also works
  // around the same quirks with basenames as in matchRoutes.
  if (pathname.charAt(0) !== '/') {
    pathname = '/' + pathname;
  }

if (!pathIsActive(pathname, currentLocation.pathname)) {
    // The path check is necessary and sufficient for indexOnly, but otherwise
    // we still need to check the routes.
    if (indexOnly || !routeIsActive(pathname, routes, params)) {
      return false;
    }
  }

return queryIsActive(query, currentLocation.query);
}
module.exports = exports['default'];

/***/ }),
/* 1261 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _Actions = __webpack_require__(105);

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _createMemoryHistory = __webpack_require__(496);

var _createMemoryHistory2 = _interopRequireDefault(_createMemoryHistory);

var _createTransitionManager = __webpack_require__(309);

var _createTransitionManager2 = _interopRequireDefault(_createTransitionManager);

var _RouteUtils = __webpack_require__(75);

var _RouterUtils = __webpack_require__(495);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * A high-level API to be used for server-side rendering.
 *
 * This function matches a location to a set of routes and calls
 * callback(error, redirectLocation, renderProps) when finished.
 *
 * Note: You probably don't want to use this in a browser unless you're using
 * server-side rendering with async routes.
 */
function match(_ref, callback) {
  var history = _ref.history;
  var routes = _ref.routes;
  var location = _ref.location;

var options = _objectWithoutProperties(_ref, ['history', 'routes', 'location']);

!(history || location) ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, 'match needs a history or a location') : (0, _invariant2.default)(false) : void 0;

history = history ? history : (0, _createMemoryHistory2.default)(options);
  var transitionManager = (0, _createTransitionManager2.default)(history, (0, _RouteUtils.createRoutes)(routes));

var unlisten = void 0;

if (location) {
    // Allow match({ location: '/the/path', ... })
    location = history.createLocation(location);
  } else {
    // Pick up the location from the history via synchronous history.listen
    // call if needed.
    unlisten = history.listen(function (historyLocation) {
      location = historyLocation;
    });
  }

var router = (0, _RouterUtils.createRouterObject)(history, transitionManager);
  history = (0, _RouterUtils.createRoutingHistory)(history, transitionManager);

transitionManager.match(location, function (error, redirectLocation, nextState) {
    callback(error, redirectLocation && router.createLocation(redirectLocation, _Actions.REPLACE), nextState && _extends({}, nextState, {
      history: history,
      router: router,
      matchContext: { history: history, transitionManager: transitionManager, router: router }
    }));

// Defer removing the listener to here to prevent DOM histories from having
    // to unwind DOM event listeners unnecessarily, in case callback renders a
    // <Router> and attaches another history listener.
    if (unlisten) {
      unlisten();
    }
  });
}

exports.default = match;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1262 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

exports.default = matchRoutes;

var _AsyncUtils = __webpack_require__(307);

var _makeStateWithLocation = __webpack_require__(498);

var _makeStateWithLocation2 = _interopRequireDefault(_makeStateWithLocation);

var _PatternUtils = __webpack_require__(112);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

var _RouteUtils = __webpack_require__(75);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function getChildRoutes(route, location, paramNames, paramValues, callback) {
  if (route.childRoutes) {
    return [null, route.childRoutes];
  }
  if (!route.getChildRoutes) {
    return [];
  }

var sync = true,
      result = void 0;

var partialNextState = {
    location: location,
    params: createParams(paramNames, paramValues)
  };

var partialNextStateWithLocation = (0, _makeStateWithLocation2.default)(partialNextState, location);

route.getChildRoutes(partialNextStateWithLocation, function (error, childRoutes) {
    childRoutes = !error && (0, _RouteUtils.createRoutes)(childRoutes);
    if (sync) {
      result = [error, childRoutes];
      return;
    }

callback(error, childRoutes);
  });

sync = false;
  return result; // Might be undefined.
}

function getIndexRoute(route, location, paramNames, paramValues, callback) {
  if (route.indexRoute) {
    callback(null, route.indexRoute);
  } else if (route.getIndexRoute) {
    var partialNextState = {
      location: location,
      params: createParams(paramNames, paramValues)
    };

var partialNextStateWithLocation = (0, _makeStateWithLocation2.default)(partialNextState, location);

route.getIndexRoute(partialNextStateWithLocation, function (error, indexRoute) {
      callback(error, !error && (0, _RouteUtils.createRoutes)(indexRoute)[0]);
    });
  } else if (route.childRoutes) {
    (function () {
      var pathless = route.childRoutes.filter(function (childRoute) {
        return !childRoute.path;
      });

(0, _AsyncUtils.loopAsync)(pathless.length, function (index, next, done) {
        getIndexRoute(pathless[index], location, paramNames, paramValues, function (error, indexRoute) {
          if (error || indexRoute) {
            var routes = [pathless[index]].concat(Array.isArray(indexRoute) ? indexRoute : [indexRoute]);
            done(error, routes);
          } else {
            next();
          }
        });
      }, function (err, routes) {
        callback(null, routes);
      });
    })();
  } else {
    callback();
  }
}

function assignParams(params, paramNames, paramValues) {
  return paramNames.reduce(function (params, paramName, index) {
    var paramValue = paramValues && paramValues[index];

if (Array.isArray(params[paramName])) {
      params[paramName].push(paramValue);
    } else if (paramName in params) {
      params[paramName] = [params[paramName], paramValue];
    } else {
      params[paramName] = paramValue;
    }

return params;
  }, params);
}

function createParams(paramNames, paramValues) {
  return assignParams({}, paramNames, paramValues);
}

function matchRouteDeep(route, location, remainingPathname, paramNames, paramValues, callback) {
  var pattern = route.path || '';

if (pattern.charAt(0) === '/') {
    remainingPathname = location.pathname;
    paramNames = [];
    paramValues = [];
  }

// Only try to match the path if the route actually has a pattern, and if
  // we're not just searching for potential nested absolute paths.
  if (remainingPathname !== null && pattern) {
    try {
      var matched = (0, _PatternUtils.matchPattern)(pattern, remainingPathname);
      if (matched) {
        remainingPathname = matched.remainingPathname;
        paramNames = [].concat(paramNames, matched.paramNames);
        paramValues = [].concat(paramValues, matched.paramValues);
      } else {
        remainingPathname = null;
      }
    } catch (error) {
      callback(error);
    }

// By assumption, pattern is non-empty here, which is the prerequisite for
    // actually terminating a match.
    if (remainingPathname === '') {
      var _ret2 = function () {
        var match = {
          routes: [route],
          params: createParams(paramNames, paramValues)
        };

getIndexRoute(route, location, paramNames, paramValues, function (error, indexRoute) {
          if (error) {
            callback(error);
          } else {
            if (Array.isArray(indexRoute)) {
              var _match$routes;

process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(indexRoute.every(function (route) {
                return !route.path;
              }), 'Index routes should not have paths') : void 0;
              (_match$routes = match.routes).push.apply(_match$routes, indexRoute);
            } else if (indexRoute) {
              process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(!indexRoute.path, 'Index routes should not have paths') : void 0;
              match.routes.push(indexRoute);
            }

callback(null, match);
          }
        });

return {
          v: void 0
        };
      }();

if ((typeof _ret2 === 'undefined' ? 'undefined' : _typeof(_ret2)) === "object") return _ret2.v;
    }
  }

if (remainingPathname != null || route.childRoutes) {
    // Either a) this route matched at least some of the path or b)
    // we don't have to load this route's children asynchronously. In
    // either case continue checking for matches in the subtree.
    var onChildRoutes = function onChildRoutes(error, childRoutes) {
      if (error) {
        callback(error);
      } else if (childRoutes) {
        // Check the child routes to see if any of them match.
        matchRoutes(childRoutes, location, function (error, match) {
          if (error) {
            callback(error);
          } else if (match) {
            // A child route matched! Augment the match and pass it up the stack.
            match.routes.unshift(route);
            callback(null, match);
          } else {
            callback();
          }
        }, remainingPathname, paramNames, paramValues);
      } else {
        callback();
      }
    };

var result = getChildRoutes(route, location, paramNames, paramValues, onChildRoutes);
    if (result) {
      onChildRoutes.apply(undefined, result);
    }
  } else {
    callback();
  }
}

/**
 * Asynchronously matches the given location to a set of routes and calls
 * callback(error, state) when finished. The state object will have the
 * following properties:
 *
 * - routes       An array of routes that matched, in hierarchical order
 * - params       An object of URL parameters
 *
 * Note: This operation may finish synchronously if no routes have an
 * asynchronous getChildRoutes method.
 */
function matchRoutes(routes, location, callback, remainingPathname) {
  var paramNames = arguments.length <= 4 || arguments[4] === undefined ? [] : arguments[4];
  var paramValues = arguments.length <= 5 || arguments[5] === undefined ? [] : arguments[5];

if (remainingPathname === undefined) {
    // TODO: This is a little bit ugly, but it works around a quirk in history
    // that strips the leading slash from pathnames when using basenames with
    // trailing slashes.
    if (location.pathname.charAt(0) !== '/') {
      location = _extends({}, location, {
        pathname: '/' + location.pathname
      });
    }
    remainingPathname = location.pathname;
  }

(0, _AsyncUtils.loopAsync)(routes.length, function (index, next, done) {
    matchRouteDeep(routes[index], location, remainingPathname, paramNames, paramValues, function (error, match) {
      if (error || match) {
        done(error, match);
      } else {
        next();
      }
    });
  }, callback);
}
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1263 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _useQueries = __webpack_require__(170);

var _useQueries2 = _interopRequireDefault(_useQueries);

var _createTransitionManager = __webpack_require__(309);

var _createTransitionManager2 = _interopRequireDefault(_createTransitionManager);

var _routerWarning = __webpack_require__(31);

var _routerWarning2 = _interopRequireDefault(_routerWarning);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Returns a new createHistory function that may be used to create
 * history objects that know about routing.
 *
 * Enhances history objects with the following methods:
 *
 * - listen((error, nextState) => {})
 * - listenBeforeLeavingRoute(route, (nextLocation) => {})
 * - match(location, (error, redirectLocation, nextState) => {})
 * - isActive(pathname, query, indexOnly=false)
 */
function useRoutes(createHistory) {
  process.env.NODE_ENV !== 'production' ? (0, _routerWarning2.default)(false, '`useRoutes` is deprecated. Please use `createTransitionManager` instead.') : void 0;

return function () {
    var _ref = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

var routes = _ref.routes;

var options = _objectWithoutProperties(_ref, ['routes']);

var history = (0, _useQueries2.default)(createHistory)(options);
    var transitionManager = (0, _createTransitionManager2.default)(history, routes);
    return _extends({}, history, transitionManager);
  };
}

exports.default = useRoutes;
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1264 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

exports.default = withRouter;

var _invariant = __webpack_require__(23);

var _invariant2 = _interopRequireDefault(_invariant);

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _hoistNonReactStatics = __webpack_require__(1265);

var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);

var _PropTypes = __webpack_require__(308);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function getDisplayName(WrappedComponent) {
  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
}

function withRouter(WrappedComponent, options) {
  var withRef = options && options.withRef;

var WithRouter = _react2.default.createClass({
    displayName: 'WithRouter',

contextTypes: { router: _PropTypes.routerShape },
    propTypes: { router: _PropTypes.routerShape },

getWrappedInstance: function getWrappedInstance() {
      !withRef ? process.env.NODE_ENV !== 'production' ? (0, _invariant2.default)(false, 'To access the wrapped instance, you need to specify ' + '`{ withRef: true }` as the second argument of the withRouter() call.') : (0, _invariant2.default)(false) : void 0;

return this.wrappedInstance;
    },
    render: function render() {
      var _this = this;

var router = this.props.router || this.context.router;
      var props = _extends({}, this.props, { router: router });

if (withRef) {
        props.ref = function (c) {
          _this.wrappedInstance = c;
        };
      }

return _react2.default.createElement(WrappedComponent, props);
    }
  });

WithRouter.displayName = 'withRouter(' + getDisplayName(WrappedComponent) + ')';
  WithRouter.WrappedComponent = WrappedComponent;

return (0, _hoistNonReactStatics2.default)(WithRouter, WrappedComponent);
}
module.exports = exports['default'];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1265 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright 2015, Yahoo! Inc.
 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
 */

var REACT_STATICS = {
    childContextTypes: true,
    contextTypes: true,
    defaultProps: true,
    displayName: true,
    getDefaultProps: true,
    mixins: true,
    propTypes: true,
    type: true
};

var KNOWN_STATICS = {
    name: true,
    length: true,
    prototype: true,
    caller: true,
    arguments: true,
    arity: true
};

var isGetOwnPropertySymbolsAvailable = typeof Object.getOwnPropertySymbols === 'function';

module.exports = function hoistNonReactStatics(targetComponent, sourceComponent, customStatics) {
    if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components
        var keys = Object.getOwnPropertyNames(sourceComponent);

/* istanbul ignore else */
        if (isGetOwnPropertySymbolsAvailable) {
            keys = keys.concat(Object.getOwnPropertySymbols(sourceComponent));
        }

for (var i = 0; i < keys.length; ++i) {
            if (!REACT_STATICS[keys[i]] && !KNOWN_STATICS[keys[i]] && (!customStatics || !customStatics[keys[i]])) {
                try {
                    targetComponent[keys[i]] = sourceComponent[keys[i]];
                } catch (error) {

}
            }
        }
    }

return targetComponent;
};

/***/ }),
/* 1266 */
/***/ (function(module, exports, __webpack_require__) {

var warning = function() {};

module.exports = warning;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1267 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _ReactComponentWithPureRenderMixin = __webpack_require__(324);

var _ReactComponentWithPureRenderMixin2 = _interopRequireDefault(_ReactComponentWithPureRenderMixin);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _Map = __webpack_require__(1268);

var _Map2 = _interopRequireDefault(_Map);

var _Slider = __webpack_require__(1269);

var _Slider2 = _interopRequireDefault(_Slider);

var _ColorUtils = __webpack_require__(1271);

var ColorUtils = _interopRequireWildcard(_ColorUtils);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var ColorPicker = _react2.default.createClass({
  displayName: "ColorPicker",

mixins: [_ReactComponentWithPureRenderMixin2.default],

propTypes: {
    color: _react2.default.PropTypes.string.isRequired,
    onChange: _react2.default.PropTypes.func.isRequired
  },

getDefaultProps: function getDefaultProps() {
    return {
      color: "rgba(0,0,0,1)",
      opacitySlider: false
    };
  },
  getInitialState: function getInitialState() {
    return this.getStateFrom(this.props);
  },
  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
    var nextState = this.getStateFrom(nextProps);

if (!ColorUtils.equals(this.state.color, nextState.color)) {
      this.setState(nextState);
    }
  },
  getStateFrom: function getStateFrom(props) {
    return {
      color: ColorUtils.parseToHsv(props.color)
    };
  },
  render: function render() {
    var classes = (0, _classnames2.default)("colorpicker", { "with-opacity-slider": this.props.opacitySlider });

var _state$color = _slicedToArray(this.state.color, 3);

var hue = _state$color[0];
    var saturation = _state$color[1];
    var value = _state$color[2];

return _react2.default.createElement(
      "div",
      { className: classes },
      _react2.default.createElement(
        "div",
        { className: "hue-slider" },
        _react2.default.createElement(_Slider2.default, {
          vertical: true,
          value: hue,
          max: 360,
          onChange: this.handleHueChange
        })
      ),
      this.props.opacitySlider && _react2.default.createElement(
        "div",
        { className: "opacity-slider" },
        _react2.default.createElement(_Slider2.default, {
          vertical: false,
          value: this.getAlpha(),
          max: 1,
          background: this.getBackgroundGradient(),
          onChange: this.handleAlphaChange
        })
      ),
      _react2.default.createElement(_Map2.default, {
        x: saturation,
        y: value,
        max: 100,
        className: ColorUtils.isDark(this.state.color) ? "dark" : "light",
        backgroundColor: this.getBackgroundHue(),
        onChange: this.handleSaturationValueChange
      })
    );
  },
  getAlpha: function getAlpha() {
    return this.state.color[3] === undefined ? 1 : this.state.color[3];
  },
  getBackgroundGradient: function getBackgroundGradient() {
    var _state$color2 = _slicedToArray(this.state.color, 3);

var h = _state$color2[0];
    var s = _state$color2[1];
    var v = _state$color2[2];

var opaque = ColorUtils.toRgbString([h, s, v, 1]);

return "linear-gradient(to right, rgba(0,0,0,0) 0%, " + opaque + " 100%)";
  },
  getBackgroundHue: function getBackgroundHue() {
    return ColorUtils.toRgbString([this.state.color[0], 100, 100]);
  },
  handleAlphaChange: function handleAlphaChange(alpha) {
    var _state$color3 = _slicedToArray(this.state.color, 3);

var h = _state$color3[0];
    var s = _state$color3[1];
    var v = _state$color3[2];

this.update([h, s, v, alpha]);
  },
  handleHueChange: function handleHueChange(hue) {
    var _state$color4 = _slicedToArray(this.state.color, 4);

var s = _state$color4[1];
    var v = _state$color4[2];
    var a = _state$color4[3];

this.update([hue, s, v, a]);
  },
  handleSaturationValueChange: function handleSaturationValueChange(saturation, value) {
    var _state$color5 = _slicedToArray(this.state.color, 4);

var h = _state$color5[0];
    var a = _state$color5[3];

this.update([h, saturation, value, a]);
  },
  update: function update(color) {
    this.setState({ color: color });
    this.props.onChange(ColorUtils.toRgbString(color));
  }
});

exports.default = ColorPicker;

/***/ }),
/* 1268 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _ReactComponentWithPureRenderMixin = __webpack_require__(324);

var _ReactComponentWithPureRenderMixin2 = _interopRequireDefault(_ReactComponentWithPureRenderMixin);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _DraggableMixin = __webpack_require__(500);

var _DraggableMixin2 = _interopRequireDefault(_DraggableMixin);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Map = _react2.default.createClass({
  displayName: "Map",

mixins: [_DraggableMixin2.default, _ReactComponentWithPureRenderMixin2.default],

propTypes: {
    x: _react2.default.PropTypes.number.isRequired,
    y: _react2.default.PropTypes.number.isRequired,
    backgroundColor: _react2.default.PropTypes.string,
    className: _react2.default.PropTypes.string
  },

getDefaultProps: function getDefaultProps() {
    return {
      x: 0,
      y: 0,
      backgroundColor: "transparent",
      className: ""
    };
  },
  updatePosition: function updatePosition(rect, clientX, clientY) {
    var x = (clientX - rect.left) / rect.width;
    var y = (rect.bottom - clientY) / rect.height;

this.props.onChange(this.getScaledValue(x), this.getScaledValue(y));
  },
  render: function render() {
    var classes = (0, _classnames2.default)("map", this.props.className, { active: this.state.active });
    var backgroundColor = this.props.backgroundColor;

return _react2.default.createElement(
      "div",
      {
        className: classes,
        onMouseDown: this.startUpdates,
        onTouchStart: this.startUpdates
      },
      _react2.default.createElement("div", { className: "background", style: { backgroundColor: backgroundColor } }),
      _react2.default.createElement("div", { className: "pointer", style: {
          left: this.getPercentageValue(this.props.x),
          bottom: this.getPercentageValue(this.props.y)
        } })
    );
  }
});

exports.default = Map;

/***/ }),
/* 1269 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _ReactComponentWithPureRenderMixin = __webpack_require__(324);

var _ReactComponentWithPureRenderMixin2 = _interopRequireDefault(_ReactComponentWithPureRenderMixin);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _DraggableMixin = __webpack_require__(500);

var _DraggableMixin2 = _interopRequireDefault(_DraggableMixin);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var Slider = _react2.default.createClass({
  displayName: "Slider",

mixins: [_DraggableMixin2.default, _ReactComponentWithPureRenderMixin2.default],

propTypes: {
    value: _react2.default.PropTypes.number.isRequired,
    vertical: _react2.default.PropTypes.bool,
    background: _react2.default.PropTypes.string
  },

getDefaultProps: function getDefaultProps() {
    return {
      value: 0,
      vertical: false,
      background: ""
    };
  },
  updatePosition: function updatePosition(rect, clientX, clientY) {
    var value = void 0;

if (this.props.vertical) {
      value = (rect.bottom - clientY) / rect.height;
    } else {
      value = (clientX - rect.left) / rect.width;
    }

this.props.onChange(this.getScaledValue(value));
  },
  getCss: function getCss() {
    var attr = this.props.vertical ? "bottom" : "left";

return _defineProperty({}, attr, this.getPercentageValue(this.props.value));
  },
  render: function render() {
    var classes = (0, _classnames2.default)("slider", this.props.vertical ? "vertical" : "horizontal");
    var background = this.props.background;

return _react2.default.createElement(
      "div",
      {
        className: classes,
        onMouseDown: this.startUpdates,
        onTouchStart: this.startUpdates
      },
      _react2.default.createElement("div", { className: "track", style: { background: background } }),
      _react2.default.createElement("div", { className: "pointer", style: this.getCss() })
    );
  }
});

exports.default = Slider;

/***/ }),
/* 1270 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var _ColorPicker = __webpack_require__(1267);

var _ColorPicker2 = _interopRequireDefault(_ColorPicker);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

module.exports = _ColorPicker2.default;

/***/ }),
/* 1271 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.parseToHsv = parseToHsv;
exports.toRgbString = toRgbString;
exports.equals = equals;
exports.isDark = isDark;

var _parse = __webpack_require__(1122);

var _parse2 = _interopRequireDefault(_parse);

var _rgb2hsv = __webpack_require__(1118);

var _rgb2hsv2 = _interopRequireDefault(_rgb2hsv);

var _hsv2rgb = __webpack_require__(1116);

var _hsv2rgb2 = _interopRequireDefault(_hsv2rgb);

var _rgb2string = __webpack_require__(1119);

var _rgb2string2 = _interopRequireDefault(_rgb2string);

var _rgb2grayscale = __webpack_require__(1117);

var _rgb2grayscale2 = _interopRequireDefault(_rgb2grayscale);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function parseToHsv(color) {
  color = (0, _parse2.default)(color);
  var hsv = (0, _rgb2hsv2.default)(color);

var alpha = color.length === 4 ? color[3] : 1;
  hsv.push(alpha);

return hsv;
}

function toRgbString(hsv) {
  var rgb = (0, _hsv2rgb2.default)(hsv);

if (hsv.length === 4) {
    rgb.push(hsv[3]);
  }

return (0, _rgb2string2.default)(rgb);
}

function equals(hsv1, hsv2) {
  return toRgbString(hsv1) === toRgbString(hsv2);
}

function isDark(hsv) {
  return (0, _rgb2grayscale2.default)((0, _hsv2rgb2.default)(hsv)) <= 128;
}

/***/ }),
/* 1272 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = clamp;
function clamp(val, min, max) {
  return Math.min(Math.max(val, min), max);
}

/***/ }),
/* 1273 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.NextArrow = exports.PrevArrow = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _innerSliderUtils = __webpack_require__(189);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var PrevArrow = exports.PrevArrow = function (_React$PureComponent) {
  _inherits(PrevArrow, _React$PureComponent);

function PrevArrow() {
    _classCallCheck(this, PrevArrow);

return _possibleConstructorReturn(this, _React$PureComponent.apply(this, arguments));
  }

PrevArrow.prototype.clickHandler = function clickHandler(options, e) {
    if (e) {
      e.preventDefault();
    }
    this.props.clickHandler(options, e);
  };

PrevArrow.prototype.render = function render() {
    var prevClasses = { "slick-arrow": true, "slick-prev": true };
    var prevHandler = this.clickHandler.bind(this, { message: "previous" });

if (!this.props.infinite && (this.props.currentSlide === 0 || this.props.slideCount <= this.props.slidesToShow)) {
      prevClasses["slick-disabled"] = true;
      prevHandler = null;
    }

if (this.props.prevArrow) {
      prevArrow = _react2.default.cloneElement(this.props.prevArrow, _extends({}, prevArrowProps, customProps));
    } else {
      prevArrow = _react2.default.createElement(
        "button",
        _extends({ key: "0", type: "button" }, prevArrowProps),
        " ",
        "Previous"
      );
    }

return prevArrow;
  };

return PrevArrow;
}(_react2.default.PureComponent);

var NextArrow = exports.NextArrow = function (_React$PureComponent2) {
  _inherits(NextArrow, _React$PureComponent2);

function NextArrow() {
    _classCallCheck(this, NextArrow);

return _possibleConstructorReturn(this, _React$PureComponent2.apply(this, arguments));
  }

NextArrow.prototype.clickHandler = function clickHandler(options, e) {
    if (e) {
      e.preventDefault();
    }
    this.props.clickHandler(options, e);
  };

NextArrow.prototype.render = function render() {
    var nextClasses = { "slick-arrow": true, "slick-next": true };
    var nextHandler = this.clickHandler.bind(this, { message: "next" });

if (!(0, _innerSliderUtils.canGoNext)(this.props)) {
      nextClasses["slick-disabled"] = true;
      nextHandler = null;
    }

if (this.props.nextArrow) {
      nextArrow = _react2.default.cloneElement(this.props.nextArrow, _extends({}, nextArrowProps, customProps));
    } else {
      nextArrow = _react2.default.createElement(
        "button",
        _extends({ key: "1", type: "button" }, nextArrowProps),
        " ",
        "Next"
      );
    }

return nextArrow;
  };

return NextArrow;
}(_react2.default.PureComponent);

/***/ }),
/* 1274 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = defaultProps;

/***/ }),
/* 1275 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.Dots = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var getDotCount = function getDotCount(spec) {
  var dots;

if (spec.infinite) {
    dots = Math.ceil(spec.slideCount / spec.slidesToScroll);
  } else {
    dots = Math.ceil((spec.slideCount - spec.slidesToShow) / spec.slidesToScroll) + 1;
  }

return dots;
};

var Dots = exports.Dots = function (_React$PureComponent) {
  _inherits(Dots, _React$PureComponent);

function Dots() {
    _classCallCheck(this, Dots);

return _possibleConstructorReturn(this, _React$PureComponent.apply(this, arguments));
  }

Dots.prototype.clickHandler = function clickHandler(options, e) {
    // In Autoplay the focus stays on clicked button even after transition
    // to next slide. That only goes away by click somewhere outside
    e.preventDefault();
    this.props.clickHandler(options);
  };

Dots.prototype.render = function render() {
    var _this2 = this;

var dotCount = getDotCount({
      slideCount: this.props.slideCount,
      slidesToScroll: this.props.slidesToScroll,
      slidesToShow: this.props.slidesToShow,
      infinite: this.props.infinite
    });

// Apply join & split to Array to pre-fill it for IE8
    //
    // Credit: http://stackoverflow.com/a/13735425/1849458
    var _props = this.props,
        onMouseEnter = _props.onMouseEnter,
        onMouseOver = _props.onMouseOver,
        onMouseLeave = _props.onMouseLeave;

var mouseEvents = { onMouseEnter: onMouseEnter, onMouseOver: onMouseOver, onMouseLeave: onMouseLeave };
    var dots = Array.apply(null, Array(dotCount + 1).join("0").split("")).map(function (x, i) {
      var leftBound = i * _this2.props.slidesToScroll;
      var rightBound = i * _this2.props.slidesToScroll + (_this2.props.slidesToScroll - 1);
      var className = (0, _classnames2.default)({
        "slick-active": _this2.props.currentSlide >= leftBound && _this2.props.currentSlide <= rightBound
      });

var dotOptions = {
        message: "dots",
        index: i,
        slidesToScroll: _this2.props.slidesToScroll,
        currentSlide: _this2.props.currentSlide
      };

var onClick = _this2.clickHandler.bind(_this2, dotOptions);
      return _react2.default.createElement(
        "li",
        { key: i, className: className },
        _react2.default.cloneElement(_this2.props.customPaging(i), { onClick: onClick })
      );
    });

return _react2.default.cloneElement(this.props.appendDots(dots), _extends({
      className: this.props.dotsClass
    }, mouseEvents));
  };

return Dots;
}(_react2.default.PureComponent);

/***/ }),
/* 1276 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;

var _slider = __webpack_require__(1279);

var _slider2 = _interopRequireDefault(_slider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _slider2.default;

/***/ }),
/* 1277 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
var initialState = {
  animating: false,
  autoplaying: null,
  currentDirection: 0,
  currentLeft: null,
  currentSlide: 0,
  direction: 1,
  dragging: false,
  edgeDragged: false,
  initialized: false,
  lazyLoadedList: [],
  listHeight: null,
  listWidth: null,
  scrolling: false,
  slideCount: null,
  slideHeight: null,
  slideWidth: null,
  swipeLeft: null,
  swiped: false, // used by swipeEvent. differentites between touch and swipe.
  swiping: false,
  touchObject: { startX: 0, startY: 0, curX: 0, curY: 0 },
  trackStyle: {},
  trackWidth: 0
};

exports.default = initialState;

/***/ }),
/* 1278 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.InnerSlider = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactDom = __webpack_require__(7);

var _reactDom2 = _interopRequireDefault(_reactDom);

var _initialState = __webpack_require__(1277);

var _initialState2 = _interopRequireDefault(_initialState);

var _lodash = __webpack_require__(962);

var _lodash2 = _interopRequireDefault(_lodash);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _innerSliderUtils = __webpack_require__(189);

var _track = __webpack_require__(1280);

var _dots = __webpack_require__(1275);

var _arrows = __webpack_require__(1273);

var _resizeObserverPolyfill = __webpack_require__(341);

var _resizeObserverPolyfill2 = _interopRequireDefault(_resizeObserverPolyfill);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var InnerSlider = exports.InnerSlider = function (_React$Component) {
  _inherits(InnerSlider, _React$Component);

function InnerSlider(props) {
    _classCallCheck(this, InnerSlider);

var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));

_this.listRefHandler = function (ref) {
      return _this.list = ref;
    };

_this.trackRefHandler = function (ref) {
      return _this.track = ref;
    };

_this.adaptHeight = function () {
      if (_this.props.adaptiveHeight && _this.list) {
        var elem = _this.list.querySelector("[data-index=\"" + _this.state.currentSlide + "\"]");
        _this.list.style.height = (0, _innerSliderUtils.getHeight)(elem) + "px";
      }
    };

_this.componentWillMount = function () {
      _this.ssrInit();
      _this.props.onInit && _this.props.onInit();
      if (_this.props.lazyLoad) {
        var slidesToLoad = (0, _innerSliderUtils.getOnDemandLazySlides)(_extends({}, _this.props, _this.state));
        if (slidesToLoad.length > 0) {
          _this.setState(function (prevState) {
            return {
              lazyLoadedList: prevState.lazyLoadedList.concat(slidesToLoad)
            };
          });
          if (_this.props.onLazyLoad) {
            _this.props.onLazyLoad(slidesToLoad);
          }
        }
      }
    };

_this.componentDidMount = function () {
      var spec = _extends({ listRef: _this.list, trackRef: _this.track }, _this.props);
      _this.updateState(spec, true, function () {
        _this.adaptHeight();
        _this.props.autoplay && _this.autoPlay("update");
      });
      if (_this.props.lazyLoad === "progressive") {
        _this.lazyLoadTimer = setInterval(_this.progressiveLazyLoad, 1000);
      }
      _this.ro = new _resizeObserverPolyfill2.default(function () {
        if (_this.state.animating) {
          _this.onWindowResized(false); // don't set trackStyle hence don't break animation
          _this.callbackTimers.push(setTimeout(function () {
            return _this.onWindowResized();
          }, _this.props.speed));
        } else {
          _this.onWindowResized();
        }
      });
      _this.ro.observe(_this.list);
      Array.prototype.forEach.call(document.querySelectorAll(".slick-slide"), function (slide) {
        slide.onfocus = _this.props.pauseOnFocus ? _this.onSlideFocus : null;
        slide.onblur = _this.props.pauseOnFocus ? _this.onSlideBlur : null;
      });
      // To support server-side rendering
      if (!window) {
        return;
      }
      if (window.addEventListener) {
        window.addEventListener("resize", _this.onWindowResized);
      } else {
        window.attachEvent("onresize", _this.onWindowResized);
      }
    };

_this.componentWillUnmount = function () {
      if (_this.animationEndCallback) {
        clearTimeout(_this.animationEndCallback);
      }
      if (_this.lazyLoadTimer) {
        clearInterval(_this.lazyLoadTimer);
      }
      if (_this.callbackTimers.length) {
        _this.callbackTimers.forEach(function (timer) {
          return clearTimeout(timer);
        });
        _this.callbackTimers = [];
      }
      if (window.addEventListener) {
        window.removeEventListener("resize", _this.onWindowResized);
      } else {
        window.detachEvent("onresize", _this.onWindowResized);
      }
      if (_this.autoplayTimer) {
        clearInterval(_this.autoplayTimer);
      }
    };

_this.componentWillReceiveProps = function (nextProps) {
      var spec = _extends({
        listRef: _this.list,
        trackRef: _this.track
      }, nextProps, _this.state);
      var setTrackStyle = false;
      for (var _iterator = Object.keys(_this.props), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
        var _ref;

if (_isArray) {
          if (_i >= _iterator.length) break;
          _ref = _iterator[_i++];
        } else {
          _i = _iterator.next();
          if (_i.done) break;
          _ref = _i.value;
        }

var key = _ref;

if (!nextProps.hasOwnProperty(key)) {
          setTrackStyle = true;
          break;
        }
        if (_typeof(nextProps[key]) === "object" || typeof nextProps[key] === "function") {
          continue;
        }
        if (nextProps[key] !== _this.props[key]) {
          setTrackStyle = true;
          break;
        }
      }
      _this.updateState(spec, setTrackStyle, function () {
        if (_this.state.currentSlide >= _react2.default.Children.count(nextProps.children)) {
          _this.changeSlide({
            message: "index",
            index: _react2.default.Children.count(nextProps.children) - nextProps.slidesToShow,
            currentSlide: _this.state.currentSlide
          });
        }
        if (nextProps.autoplay) {
          _this.autoPlay("update");
        } else {
          _this.pause("paused");
        }
      });
    };

_this.componentDidUpdate = function () {
      _this.checkImagesLoad();
      _this.props.onReInit && _this.props.onReInit();
      if (_this.props.lazyLoad) {
        var slidesToLoad = (0, _innerSliderUtils.getOnDemandLazySlides)(_extends({}, _this.props, _this.state));
        if (slidesToLoad.length > 0) {
          _this.setState(function (prevState) {
            return {
              lazyLoadedList: prevState.lazyLoadedList.concat(slidesToLoad)
            };
          });
          if (_this.props.onLazyLoad) {
            _this.props.onLazyLoad(slidesToLoad);
          }
        }
      }
      // if (this.props.onLazyLoad) {
      //   this.props.onLazyLoad([leftMostSlide])
      // }
      _this.adaptHeight();
    };

_this.onWindowResized = function (setTrackStyle) {
      if (_this.debouncedResize) _this.debouncedResize.cancel();
      _this.debouncedResize = (0, _lodash2.default)(function () {
        return _this.resizeWindow(setTrackStyle);
      }, 50);
      _this.debouncedResize();
    };

_this.resizeWindow = function () {
      var setTrackStyle = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

if (!_reactDom2.default.findDOMNode(_this.track)) return;
      var spec = _extends({
        listRef: _this.list,
        trackRef: _this.track
      }, _this.props, _this.state);
      _this.updateState(spec, setTrackStyle, function () {
        if (_this.props.autoplay) _this.autoPlay("update");else _this.pause("paused");
      });
      // animating state should be cleared while resizing, otherwise autoplay stops working
      _this.setState({
        animating: false
      });
      clearTimeout(_this.animationEndCallback);
      delete _this.animationEndCallback;
    };

_this.updateState = function (spec, setTrackStyle, callback) {
      var updatedState = (0, _innerSliderUtils.initializedState)(spec);
      spec = _extends({}, spec, updatedState, { slideIndex: updatedState.currentSlide });
      var targetLeft = (0, _innerSliderUtils.getTrackLeft)(spec);
      spec = _extends({}, spec, { left: targetLeft });
      var trackStyle = (0, _innerSliderUtils.getTrackCSS)(spec);
      if (setTrackStyle || _react2.default.Children.count(_this.props.children) !== _react2.default.Children.count(spec.children)) {
        updatedState["trackStyle"] = trackStyle;
      }
      _this.setState(updatedState, callback);
    };

_this.ssrInit = function () {
      if (_this.props.variableWidth) {
        var _trackWidth = 0,
            _trackLeft = 0;
        var childrenWidths = [];
        var preClones = (0, _innerSliderUtils.getPreClones)(_extends({}, _this.props, _this.state, {
          slideCount: _this.props.children.length
        }));
        var postClones = (0, _innerSliderUtils.getPostClones)(_extends({}, _this.props, _this.state, {
          slideCount: _this.props.children.length
        }));
        _this.props.children.forEach(function (child) {
          childrenWidths.push(child.props.style.width);
          _trackWidth += child.props.style.width;
        });
        for (var i = 0; i < preClones; i++) {
          _trackLeft += childrenWidths[childrenWidths.length - 1 - i];
          _trackWidth += childrenWidths[childrenWidths.length - 1 - i];
        }
        for (var _i2 = 0; _i2 < postClones; _i2++) {
          _trackWidth += childrenWidths[_i2];
        }
        for (var _i3 = 0; _i3 < _this.state.currentSlide; _i3++) {
          _trackLeft += childrenWidths[_i3];
        }
        var _trackStyle = {
          width: _trackWidth + "px",
          left: -_trackLeft + "px"
        };
        if (_this.props.centerMode) {
          var currentWidth = childrenWidths[_this.state.currentSlide] + "px";
          _trackStyle.left = "calc(" + _trackStyle.left + " + (100% - " + currentWidth + ") / 2 ) ";
        }
        _this.setState({
          trackStyle: _trackStyle
        });
        return;
      }
      var childrenCount = _react2.default.Children.count(_this.props.children);
      var spec = _extends({}, _this.props, _this.state, { slideCount: childrenCount });
      var slideCount = (0, _innerSliderUtils.getPreClones)(spec) + (0, _innerSliderUtils.getPostClones)(spec) + childrenCount;
      var trackWidth = 100 / _this.props.slidesToShow * slideCount;
      var slideWidth = 100 / slideCount;
      var trackLeft = -slideWidth * ((0, _innerSliderUtils.getPreClones)(spec) + _this.state.currentSlide) * trackWidth / 100;
      if (_this.props.centerMode) {
        trackLeft += (100 - slideWidth * trackWidth / 100) / 2;
      }
      var trackStyle = {
        width: trackWidth + "%",
        left: trackLeft + "%"
      };
      _this.setState({
        slideWidth: slideWidth + "%",
        trackStyle: trackStyle
      });
    };

_this.checkImagesLoad = function () {
      var images = document.querySelectorAll(".slick-slide img");
      var imagesCount = images.length,
          loadedCount = 0;
      Array.prototype.forEach.call(images, function (image) {
        var handler = function handler() {
          return ++loadedCount && loadedCount >= imagesCount && _this.onWindowResized();
        };
        if (!image.onclick) {
          image.onclick = function () {
            return image.parentNode.focus();
          };
        } else {
          var prevClickHandler = image.onclick;
          image.onclick = function () {
            prevClickHandler();
            image.parentNode.focus();
          };
        }
        if (!image.onload) {
          if (_this.props.lazyLoad) {
            image.onload = function () {
              _this.adaptHeight();
              _this.callbackTimers.push(setTimeout(_this.onWindowResized, _this.props.speed));
            };
          } else {
            image.onload = handler;
            image.onerror = function () {
              handler();
              _this.props.onLazyLoadError && _this.props.onLazyLoadError();
            };
          }
        }
      });
    };

_this.progressiveLazyLoad = function () {
      var slidesToLoad = [];
      var spec = _extends({}, _this.props, _this.state);
      for (var index = _this.state.currentSlide; index < _this.state.slideCount + (0, _innerSliderUtils.getPostClones)(spec); index++) {
        if (_this.state.lazyLoadedList.indexOf(index) < 0) {
          slidesToLoad.push(index);
          break;
        }
      }
      for (var _index = _this.state.currentSlide - 1; _index >= -(0, _innerSliderUtils.getPreClones)(spec); _index--) {
        if (_this.state.lazyLoadedList.indexOf(_index) < 0) {
          slidesToLoad.push(_index);
          break;
        }
      }
      if (slidesToLoad.length > 0) {
        _this.setState(function (state) {
          return {
            lazyLoadedList: state.lazyLoadedList.concat(slidesToLoad)
          };
        });
        if (_this.props.onLazyLoad) {
          _this.props.onLazyLoad(slidesToLoad);
        }
      } else {
        if (_this.lazyLoadTimer) {
          clearInterval(_this.lazyLoadTimer);
          delete _this.lazyLoadTimer;
        }
      }
    };

_this.slideHandler = function (index) {
      var dontAnimate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      var _this$props = _this.props,
          asNavFor = _this$props.asNavFor,
          beforeChange = _this$props.beforeChange,
          onLazyLoad = _this$props.onLazyLoad,
          speed = _this$props.speed,
          afterChange = _this$props.afterChange;
      // capture currentslide before state is updated

var currentSlide = _this.state.currentSlide;

var _slideHandler = (0, _innerSliderUtils.slideHandler)(_extends({
        index: index
      }, _this.props, _this.state, {
        trackRef: _this.track,
        useCSS: _this.props.useCSS && !dontAnimate
      })),
          state = _slideHandler.state,
          nextState = _slideHandler.nextState;

if (!state) return;
      beforeChange && beforeChange(currentSlide, state.currentSlide);
      var slidesToLoad = state.lazyLoadedList.filter(function (value) {
        return _this.state.lazyLoadedList.indexOf(value) < 0;
      });
      onLazyLoad && slidesToLoad.length > 0 && onLazyLoad(slidesToLoad);
      _this.setState(state, function () {
        asNavFor && asNavFor.innerSlider.state.currentSlide !== currentSlide && asNavFor.innerSlider.slideHandler(index);
        if (!nextState) return;
        _this.animationEndCallback = setTimeout(function () {
          var animating = nextState.animating,
              firstBatch = _objectWithoutProperties(nextState, ["animating"]);

_this.setState(firstBatch, function () {
            _this.callbackTimers.push(setTimeout(function () {
              return _this.setState({ animating: animating });
            }, 10));
            afterChange && afterChange(state.currentSlide);
            delete _this.animationEndCallback;
          });
        }, speed);
      });
    };

_this.changeSlide = function (options) {
      var dontAnimate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

_this.clickHandler = function (e) {
      if (_this.clickable === false) {
        e.stopPropagation();
        e.preventDefault();
      }
      _this.clickable = true;
    };

_this.keyHandler = function (e) {
      var dir = (0, _innerSliderUtils.keyHandler)(e, _this.props.accessibility, _this.props.rtl);
      dir !== "" && _this.changeSlide({ message: dir });
    };

_this.selectHandler = function (options) {
      _this.changeSlide(options);
    };

_this.disableBodyScroll = function () {
      var preventDefault = function preventDefault(e) {
        e = e || window.event;
        if (e.preventDefault) e.preventDefault();
        e.returnValue = false;
      };
      window.ontouchmove = preventDefault;
    };

_this.enableBodyScroll = function () {
      window.ontouchmove = null;
    };

_this.swipeStart = function (e) {
      if (_this.props.verticalSwiping) {
        _this.disableBodyScroll();
      }
      var state = (0, _innerSliderUtils.swipeStart)(e, _this.props.swipe, _this.props.draggable);
      state !== "" && _this.setState(state);
    };

_this.swipeMove = function (e) {
      var state = (0, _innerSliderUtils.swipeMove)(e, _extends({}, _this.props, _this.state, {
        trackRef: _this.track,
        listRef: _this.list,
        slideIndex: _this.state.currentSlide
      }));
      if (!state) return;
      if (state["swiping"]) {
        _this.clickable = false;
      }
      _this.setState(state);
    };

_this.swipeEnd = function (e) {
      var state = (0, _innerSliderUtils.swipeEnd)(e, _extends({}, _this.props, _this.state, {
        trackRef: _this.track,
        listRef: _this.list,
        slideIndex: _this.state.currentSlide
      }));
      if (!state) return;
      var triggerSlideHandler = state["triggerSlideHandler"];
      delete state["triggerSlideHandler"];
      _this.setState(state);
      if (triggerSlideHandler === undefined) return;
      _this.slideHandler(triggerSlideHandler);
      if (_this.props.verticalSwiping) {
        _this.enableBodyScroll();
      }
    };

_this.slickPrev = function () {
      // this and fellow methods are wrapped in setTimeout
      // to make sure initialize setState has happened before
      // any of such methods are called
      _this.callbackTimers.push(setTimeout(function () {
        return _this.changeSlide({ message: "previous" });
      }, 0));
    };

_this.slickNext = function () {
      _this.callbackTimers.push(setTimeout(function () {
        return _this.changeSlide({ message: "next" });
      }, 0));
    };

_this.slickGoTo = function (slide) {
      var dontAnimate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

slide = Number(slide);
      if (isNaN(slide)) return "";
      _this.callbackTimers.push(setTimeout(function () {
        return _this.changeSlide({
          message: "index",
          index: slide,
          currentSlide: _this.state.currentSlide
        }, dontAnimate);
      }, 0));
    };

_this.play = function () {
      var nextIndex;
      if (_this.props.rtl) {
        nextIndex = _this.state.currentSlide - _this.props.slidesToScroll;
      } else {
        if ((0, _innerSliderUtils.canGoNext)(_extends({}, _this.props, _this.state))) {
          nextIndex = _this.state.currentSlide + _this.props.slidesToScroll;
        } else {
          return false;
        }
      }

_this.slideHandler(nextIndex);
    };

_this.autoPlay = function (playType) {
      if (_this.autoplayTimer) {
        clearInterval(_this.autoplayTimer);
      }
      var autoplaying = _this.state.autoplaying;
      if (playType === "update") {
        if (autoplaying === "hovered" || autoplaying === "focused" || autoplaying === "paused") {
          return;
        }
      } else if (playType === "leave") {
        if (autoplaying === "paused" || autoplaying === "focused") {
          return;
        }
      } else if (playType === "blur") {
        if (autoplaying === "paused" || autoplaying === "hovered") {
          return;
        }
      }
      _this.autoplayTimer = setInterval(_this.play, _this.props.autoplaySpeed + 50);
      _this.setState({ autoplaying: "playing" });
    };

_this.pause = function (pauseType) {
      if (_this.autoplayTimer) {
        clearInterval(_this.autoplayTimer);
        _this.autoplayTimer = null;
      }
      var autoplaying = _this.state.autoplaying;
      if (pauseType === "paused") {
        _this.setState({ autoplaying: "paused" });
      } else if (pauseType === "focused") {
        if (autoplaying === "hovered" || autoplaying === "playing") {
          _this.setState({ autoplaying: "focused" });
        }
      } else {
        // pauseType  is 'hovered'
        if (autoplaying === "playing") {
          _this.setState({ autoplaying: "hovered" });
        }
      }
    };

_this.onDotsOver = function () {
      return _this.props.autoplay && _this.pause("hovered");
    };

_this.onDotsLeave = function () {
      return _this.props.autoplay && _this.state.autoplaying === "hovered" && _this.autoPlay("leave");
    };

_this.onTrackOver = function () {
      return _this.props.autoplay && _this.pause("hovered");
    };

_this.onTrackLeave = function () {
      return _this.props.autoplay && _this.state.autoplaying === "hovered" && _this.autoPlay("leave");
    };

_this.onSlideFocus = function () {
      return _this.props.autoplay && _this.pause("focused");
    };

_this.onSlideBlur = function () {
      return _this.props.autoplay && _this.state.autoplaying === "focused" && _this.autoPlay("blur");
    };

_this.render = function () {
      var className = (0, _classnames2.default)("slick-slider", _this.props.className, {
        "slick-vertical": _this.props.vertical,
        "slick-initialized": true
      });
      var spec = _extends({}, _this.props, _this.state);
      var trackProps = (0, _innerSliderUtils.extractObject)(spec, ["fade", "cssEase", "speed", "infinite", "centerMode", "focusOnSelect", "currentSlide", "lazyLoad", "lazyLoadedList", "rtl", "slideWidth", "slideHeight", "listHeight", "vertical", "slidesToShow", "slidesToScroll", "slideCount", "trackStyle", "variableWidth", "unslick", "centerPadding"]);
      var pauseOnHover = _this.props.pauseOnHover;

trackProps = _extends({}, trackProps, {
        onMouseEnter: pauseOnHover ? _this.onTrackOver : null,
        onMouseLeave: pauseOnHover ? _this.onTrackLeave : null,
        onMouseOver: pauseOnHover ? _this.onTrackOver : null,
        focusOnSelect: _this.props.focusOnSelect ? _this.selectHandler : null
      });

var dots;
      if (_this.props.dots === true && _this.state.slideCount >= _this.props.slidesToShow) {
        var dotProps = (0, _innerSliderUtils.extractObject)(spec, ["dotsClass", "slideCount", "slidesToShow", "currentSlide", "slidesToScroll", "clickHandler", "children", "customPaging", "infinite", "appendDots"]);
        var pauseOnDotsHover = _this.props.pauseOnDotsHover;

dotProps = _extends({}, dotProps, {
          clickHandler: _this.changeSlide,
          onMouseEnter: pauseOnDotsHover ? _this.onDotsLeave : null,
          onMouseOver: pauseOnDotsHover ? _this.onDotsOver : null,
          onMouseLeave: pauseOnDotsHover ? _this.onDotsLeave : null
        });
        dots = _react2.default.createElement(_dots.Dots, dotProps);
      }

var prevArrow, nextArrow;
      var arrowProps = (0, _innerSliderUtils.extractObject)(spec, ["infinite", "centerMode", "currentSlide", "slideCount", "slidesToShow", "prevArrow", "nextArrow"]);
      arrowProps.clickHandler = _this.changeSlide;

if (_this.props.arrows) {
        prevArrow = _react2.default.createElement(_arrows.PrevArrow, arrowProps);
        nextArrow = _react2.default.createElement(_arrows.NextArrow, arrowProps);
      }

var verticalHeightStyle = null;

if (_this.props.vertical) {
        verticalHeightStyle = {
          height: _this.state.listHeight
        };
      }

var centerPaddingStyle = null;

if (_this.props.vertical === false) {
        if (_this.props.centerMode === true) {
          centerPaddingStyle = {
            padding: "0px " + _this.props.centerPadding
          };
        }
      } else {
        if (_this.props.centerMode === true) {
          centerPaddingStyle = {
            padding: _this.props.centerPadding + " 0px"
          };
        }
      }

var listStyle = _extends({}, verticalHeightStyle, centerPaddingStyle);
      var touchMove = _this.props.touchMove;
      var listProps = {
        className: "slick-list",
        style: listStyle,
        onClick: _this.clickHandler,
        onMouseDown: touchMove ? _this.swipeStart : null,
        onMouseMove: _this.state.dragging && touchMove ? _this.swipeMove : null,
        onMouseUp: touchMove ? _this.swipeEnd : null,
        onMouseLeave: _this.state.dragging && touchMove ? _this.swipeEnd : null,
        onTouchStart: touchMove ? _this.swipeStart : null,
        onTouchMove: _this.state.dragging && touchMove ? _this.swipeMove : null,
        onTouchEnd: touchMove ? _this.swipeEnd : null,
        onTouchCancel: _this.state.dragging && touchMove ? _this.swipeEnd : null,
        onKeyDown: _this.props.accessibility ? _this.keyHandler : null
      };

var innerSliderProps = {
        className: className,
        dir: "ltr"
      };

if (_this.props.unslick) {
        listProps = { className: "slick-list" };
        innerSliderProps = { className: className };
      }
      return _react2.default.createElement(
        "div",
        innerSliderProps,
        !_this.props.unslick ? prevArrow : "",
        _react2.default.createElement(
          "div",
          _extends({ ref: _this.listRefHandler }, listProps),
          _react2.default.createElement(
            _track.Track,
            _extends({ ref: _this.trackRefHandler }, trackProps),
            _this.props.children
          )
        ),
        !_this.props.unslick ? nextArrow : "",
        !_this.props.unslick ? dots : ""
      );
    };

_this.list = null;
    _this.track = null;
    _this.state = _extends({}, _initialState2.default, {
      currentSlide: _this.props.initialSlide,
      slideCount: _react2.default.Children.count(_this.props.children)
    });
    _this.callbackTimers = [];
    _this.clickable = true;
    _this.debouncedResize = null;
    return _this;
  }

return InnerSlider;
}(_react2.default.Component);

/***/ }),
/* 1279 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _innerSlider = __webpack_require__(1278);

var _json2mq = __webpack_require__(961);

var _json2mq2 = _interopRequireDefault(_json2mq);

var _defaultProps = __webpack_require__(1274);

var _defaultProps2 = _interopRequireDefault(_defaultProps);

var _innerSliderUtils = __webpack_require__(189);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var enquire = (0, _innerSliderUtils.canUseDOM)() && __webpack_require__(881);

var Slider = function (_React$Component) {
  _inherits(Slider, _React$Component);

function Slider(props) {
    _classCallCheck(this, Slider);

var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));

_this.innerSliderRefHandler = function (ref) {
      return _this.innerSlider = ref;
    };

_this.slickPrev = function () {
      return _this.innerSlider.slickPrev();
    };

_this.slickNext = function () {
      return _this.innerSlider.slickNext();
    };

_this.slickGoTo = function (slide) {
      var dontAnimate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      return _this.innerSlider.slickGoTo(slide, dontAnimate);
    };

_this.slickPause = function () {
      return _this.innerSlider.pause("paused");
    };

_this.slickPlay = function () {
      return _this.innerSlider.autoPlay("play");
    };

_this.state = {
      breakpoint: null
    };
    _this._responsiveMediaHandlers = [];
    return _this;
  }

Slider.prototype.media = function media(query, handler) {
    // javascript handler for  css media query
    enquire.register(query, handler);
    this._responsiveMediaHandlers.push({ query: query, handler: handler });
  };

// handles responsive breakpoints

Slider.prototype.componentWillMount = function componentWillMount() {
    var _this2 = this;

// performance monitoring
    //if (process.env.NODE_ENV !== 'production') {
    //const { whyDidYouUpdate } = require('why-did-you-update')
    //whyDidYouUpdate(React)
    //}
    if (this.props.responsive) {
      var breakpoints = this.props.responsive.map(function (breakpt) {
        return breakpt.breakpoint;
      });
      // sort them in increasing order of their numerical value
      breakpoints.sort(function (x, y) {
        return x - y;
      });

breakpoints.forEach(function (breakpoint, index) {
        // media query for each breakpoint
        var bQuery = void 0;
        if (index === 0) {
          bQuery = (0, _json2mq2.default)({ minWidth: 0, maxWidth: breakpoint });
        } else {
          bQuery = (0, _json2mq2.default)({
            minWidth: breakpoints[index - 1] + 1,
            maxWidth: breakpoint
          });
        }
        // when not using server side rendering
        (0, _innerSliderUtils.canUseDOM)() && _this2.media(bQuery, function () {
          _this2.setState({ breakpoint: breakpoint });
        });
      });

// Register media query for full screen. Need to support resize from small to large
      // convert javascript object to media query string
      var query = (0, _json2mq2.default)({ minWidth: breakpoints.slice(-1)[0] });

(0, _innerSliderUtils.canUseDOM)() && this.media(query, function () {
        _this2.setState({ breakpoint: null });
      });
    }
  };

Slider.prototype.componentWillUnmount = function componentWillUnmount() {
    this._responsiveMediaHandlers.forEach(function (obj) {
      enquire.unregister(obj.query, obj.handler);
    });
  };

Slider.prototype.render = function render() {
    var _this3 = this;

var settings;
    var newProps;
    if (this.state.breakpoint) {
      newProps = this.props.responsive.filter(function (resp) {
        return resp.breakpoint === _this3.state.breakpoint;
      });
      settings = newProps[0].settings === "unslick" ? "unslick" : _extends({}, _defaultProps2.default, this.props, newProps[0].settings);
    } else {
      settings = _extends({}, _defaultProps2.default, this.props);
    }

// force scrolling by one if centerMode is on
    if (settings.centerMode) {
      if (settings.slidesToScroll > 1 && process.env.NODE_ENV !== "production") {
        console.warn("slidesToScroll should be equal to 1 in centerMode, you are using " + settings.slidesToScroll);
      }
      settings.slidesToScroll = 1;
    }
    // force showing one slide and scrolling by one if the fade mode is on
    if (settings.fade) {
      if (settings.slidesToShow > 1 && process.env.NODE_ENV !== "production") {
        console.warn("slidesToShow should be equal to 1 when fade is true, you're using " + settings.slidesToShow);
      }
      if (settings.slidesToScroll > 1 && process.env.NODE_ENV !== "production") {
        console.warn("slidesToScroll should be equal to 1 when fade is true, you're using " + settings.slidesToScroll);
      }
      settings.slidesToShow = 1;
      settings.slidesToScroll = 1;
    }

// makes sure that children is an array, even when there is only 1 child
    var children = _react2.default.Children.toArray(this.props.children);

// Children may contain false or null, so we should filter them
    // children may also contain string filled with spaces (in certain cases where we use jsx strings)
    children = children.filter(function (child) {
      if (typeof child === "string") {
        return !!child.trim();
      }
      return !!child;
    });

// rows and slidesPerRow logic is handled here
    if (settings.variableWidth && (settings.rows > 1 || settings.slidesPerRow > 1)) {
      console.warn("variableWidth is not supported in case of rows > 1 or slidesPerRow > 1");
      settings.variableWidth = false;
    }
    var newChildren = [];
    var currentWidth = null;
    for (var i = 0; i < children.length; i += settings.rows * settings.slidesPerRow) {
      var newSlide = [];
      for (var j = i; j < i + settings.rows * settings.slidesPerRow; j += settings.slidesPerRow) {
        var row = [];
        for (var k = j; k < j + settings.slidesPerRow; k += 1) {
          if (settings.variableWidth && children[k].props.style) {
            currentWidth = children[k].props.style.width;
          }
          if (k >= children.length) break;
          row.push(_react2.default.cloneElement(children[k], {
            key: 100 * i + 10 * j + k,
            tabIndex: -1,
            style: {
              width: 100 / settings.slidesPerRow + "%",
              display: "inline-block"
            }
          }));
        }
        newSlide.push(_react2.default.createElement(
          "div",
          { key: 10 * i + j },
          row
        ));
      }
      if (settings.variableWidth) {
        newChildren.push(_react2.default.createElement(
          "div",
          { key: i, style: { width: currentWidth } },
          newSlide
        ));
      } else {
        newChildren.push(_react2.default.createElement(
          "div",
          { key: i },
          newSlide
        ));
      }
    }

if (settings === "unslick") {
      var className = "regular slider " + (this.props.className || "");
      return _react2.default.createElement(
        "div",
        { className: className },
        newChildren
      );
    } else if (newChildren.length <= settings.slidesToShow) {
      settings.unslick = true;
    }
    return _react2.default.createElement(
      _innerSlider.InnerSlider,
      _extends({ ref: this.innerSliderRefHandler }, settings),
      newChildren
    );
  };

return Slider;
}(_react2.default.Component);

exports.default = Slider;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1280 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.Track = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _innerSliderUtils = __webpack_require__(189);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// given specifications/props for a slide, fetch all the classes that need to be applied to the slide
var getSlideClasses = function getSlideClasses(spec) {
  var slickActive, slickCenter, slickCloned;
  var centerOffset, index;

if (spec.rtl) {
    index = spec.slideCount - 1 - spec.index;
  } else {
    index = spec.index;
  }
  slickCloned = index < 0 || index >= spec.slideCount;
  if (spec.centerMode) {
    centerOffset = Math.floor(spec.slidesToShow / 2);
    slickCenter = (index - spec.currentSlide) % spec.slideCount === 0;
    if (index > spec.currentSlide - centerOffset - 1 && index <= spec.currentSlide + centerOffset) {
      slickActive = true;
    }
  } else {
    slickActive = spec.currentSlide <= index && index < spec.currentSlide + spec.slidesToShow;
  }
  var slickCurrent = index === spec.currentSlide;
  return {
    "slick-slide": true,
    "slick-active": slickActive,
    "slick-center": slickCenter,
    "slick-cloned": slickCloned,
    "slick-current": slickCurrent // dubious in case of RTL
  };
};

var getSlideStyle = function getSlideStyle(spec) {
  var style = {};

if (spec.variableWidth === undefined || spec.variableWidth === false) {
    style.width = spec.slideWidth;
  }

if (spec.fade) {
    style.position = "relative";
    if (spec.vertical) {
      style.top = -spec.index * parseInt(spec.slideHeight);
    } else {
      style.left = -spec.index * parseInt(spec.slideWidth);
    }
    style.opacity = spec.currentSlide === spec.index ? 1 : 0;
    style.transition = "opacity " + spec.speed + "ms " + spec.cssEase + ", " + "visibility " + spec.speed + "ms " + spec.cssEase;
    style.WebkitTransition = "opacity " + spec.speed + "ms " + spec.cssEase + ", " + "visibility " + spec.speed + "ms " + spec.cssEase;
  }

return style;
};

var getKey = function getKey(child, fallbackKey) {
  return child.key || fallbackKey;
};

var renderSlides = function renderSlides(spec) {
  var key;
  var slides = [];
  var preCloneSlides = [];
  var postCloneSlides = [];
  var childrenCount = _react2.default.Children.count(spec.children);
  var startIndex = (0, _innerSliderUtils.lazyStartIndex)(spec);
  var endIndex = (0, _innerSliderUtils.lazyEndIndex)(spec);

_react2.default.Children.forEach(spec.children, function (elem, index) {
    var child = void 0;
    var childOnClickOptions = {
      message: "children",
      index: index,
      slidesToScroll: spec.slidesToScroll,
      currentSlide: spec.currentSlide
    };

// in case of lazyLoad, whether or not we want to fetch the slide
    if (!spec.lazyLoad || spec.lazyLoad && spec.lazyLoadedList.indexOf(index) >= 0) {
      child = elem;
    } else {
      child = _react2.default.createElement("div", null);
    }
    var childStyle = getSlideStyle(_extends({}, spec, { index: index }));
    var slideClass = child.props.className || "";
    var slideClasses = getSlideClasses(_extends({}, spec, { index: index }));
    // push a cloned element of the desired slide
    slides.push(_react2.default.cloneElement(child, {
      key: "original" + getKey(child, index),
      "data-index": index,
      className: (0, _classnames2.default)(slideClasses, slideClass),
      tabIndex: "-1",
      "aria-hidden": !slideClasses["slick-active"],
      style: _extends({ outline: "none" }, child.props.style || {}, childStyle),
      onClick: function onClick(e) {
        child.props && child.props.onClick && child.props.onClick(e);
        if (spec.focusOnSelect) {
          spec.focusOnSelect(childOnClickOptions);
        }
      }
    }));

// if slide needs to be precloned or postcloned
    if (spec.infinite && spec.fade === false) {
      var preCloneNo = childrenCount - index;
      if (preCloneNo <= (0, _innerSliderUtils.getPreClones)(spec) && childrenCount !== spec.slidesToShow) {
        key = -preCloneNo;
        if (key >= startIndex) {
          child = elem;
        }
        slideClasses = getSlideClasses(_extends({}, spec, { index: key }));
        preCloneSlides.push(_react2.default.cloneElement(child, {
          key: "precloned" + getKey(child, key),
          "data-index": key,
          tabIndex: "-1",
          className: (0, _classnames2.default)(slideClasses, slideClass),
          "aria-hidden": !slideClasses["slick-active"],
          style: _extends({}, child.props.style || {}, childStyle),
          onClick: function onClick(e) {
            child.props && child.props.onClick && child.props.onClick(e);
            if (spec.focusOnSelect) {
              spec.focusOnSelect(childOnClickOptions);
            }
          }
        }));
      }

if (childrenCount !== spec.slidesToShow) {
        key = childrenCount + index;
        if (key < endIndex) {
          child = elem;
        }
        slideClasses = getSlideClasses(_extends({}, spec, { index: key }));
        postCloneSlides.push(_react2.default.cloneElement(child, {
          key: "postcloned" + getKey(child, key),
          "data-index": key,
          tabIndex: "-1",
          className: (0, _classnames2.default)(slideClasses, slideClass),
          "aria-hidden": !slideClasses["slick-active"],
          style: _extends({}, child.props.style || {}, childStyle),
          onClick: function onClick(e) {
            child.props && child.props.onClick && child.props.onClick(e);
            if (spec.focusOnSelect) {
              spec.focusOnSelect(childOnClickOptions);
            }
          }
        }));
      }
    }
  });

if (spec.rtl) {
    return preCloneSlides.concat(slides, postCloneSlides).reverse();
  } else {
    return preCloneSlides.concat(slides, postCloneSlides);
  }
};

var Track = exports.Track = function (_React$PureComponent) {
  _inherits(Track, _React$PureComponent);

function Track() {
    _classCallCheck(this, Track);

return _possibleConstructorReturn(this, _React$PureComponent.apply(this, arguments));
  }

Track.prototype.render = function render() {
    var slides = renderSlides(this.props);
    var _props = this.props,
        onMouseEnter = _props.onMouseEnter,
        onMouseOver = _props.onMouseOver,
        onMouseLeave = _props.onMouseLeave;

var mouseEvents = { onMouseEnter: onMouseEnter, onMouseOver: onMouseOver, onMouseLeave: onMouseLeave };
    return _react2.default.createElement(
      "div",
      _extends({
        className: "slick-track",
        style: this.props.trackStyle
      }, mouseEvents),
      slides
    );
  };

return Track;
}(_react2.default.PureComponent);

/***/ }),
/* 1281 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactDom = __webpack_require__(7);

var _lodashLangIsEqual = __webpack_require__(1309);

var _lodashLangIsEqual2 = _interopRequireDefault(_lodashLangIsEqual);

var _lodashLangClone = __webpack_require__(1308);

var _lodashLangClone2 = _interopRequireDefault(_lodashLangClone);

var _helpersUuid = __webpack_require__(1283);

var _helpersUuid2 = _interopRequireDefault(_helpersUuid);

var _helpersUcFirst = __webpack_require__(1282);

var _helpersUcFirst2 = _interopRequireDefault(_helpersUcFirst);

// Include all of the Native DOM and custom events from:
// https://github.com/tinymce/tinymce/blob/master/tools/docs/tinymce.Editor.js#L5-L12
var EVENTS = ['focusin', 'focusout', 'click', 'dblclick', 'mousedown', 'mouseup', 'mousemove', 'mouseover', 'beforepaste', 'paste', 'cut', 'copy', 'selectionchange', 'mouseout', 'mouseenter', 'mouseleave', 'keydown', 'keypress', 'keyup', 'contextmenu', 'dragend', 'dragover', 'draggesture', 'dragdrop', 'drop', 'drag', 'BeforeRenderUI', 'SetAttrib', 'PreInit', 'PostRender', 'init', 'deactivate', 'activate', 'NodeChange', 'BeforeExecCommand', 'ExecCommand', 'show', 'hide', 'ProgressState', 'LoadContent', 'SaveContent', 'BeforeSetContent', 'SetContent', 'BeforeGetContent', 'GetContent', 'VisualAid', 'remove', 'submit', 'reset', 'BeforeAddUndo', 'AddUndo', 'change', 'undo', 'redo', 'ClearUndos', 'ObjectSelected', 'ObjectResizeStart', 'ObjectResized', 'PreProcess', 'PostProcess', 'focus', 'blur', 'dirty'];

// Note: because the capitalization of the events is weird, we're going to get
// some inconsistently-named handlers, for example compare:
// 'onMouseleave' and 'onNodeChange'
var HANDLER_NAMES = EVENTS.map(function (event) {
  return 'on' + (0, _helpersUcFirst2['default'])(event);
});

var TinyMCE = _react2['default'].createClass({
  displayName: 'TinyMCE',

propTypes: {
    config: _react2['default'].PropTypes.object,
    content: _react2['default'].PropTypes.string,
    id: _react2['default'].PropTypes.string,
    className: _react2['default'].PropTypes.string
  },

getDefaultProps: function getDefaultProps() {
    return {
      config: {},
      content: ''
    };
  },

componentWillMount: function componentWillMount() {
    this.id = this.id || this.props.id || (0, _helpersUuid2['default'])();
  },

componentDidMount: function componentDidMount() {
    var config = (0, _lodashLangClone2['default'])(this.props.config);
    this._init(config);
  },

componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
    if (!(0, _lodashLangIsEqual2['default'])(this.props.config, nextProps.config)) {
      this._init(nextProps.config, nextProps.content);
    }
    if (!(0, _lodashLangIsEqual2['default'])(this.props.id, nextProps.id)) {
      this.id = nextProps.id;
    }
  },

shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
    return !(0, _lodashLangIsEqual2['default'])(this.props.content, nextProps.content) || !(0, _lodashLangIsEqual2['default'])(this.props.config, nextProps.config);
  },

componentWillUnmount: function componentWillUnmount() {
    this._remove();
  },

render: function render() {
    return this.props.config.inline ? _react2['default'].createElement('div', {
      id: this.id,
      className: this.props.className,
      dangerouslySetInnerHTML: { __html: this.props.content }
    }) : _react2['default'].createElement('textarea', {
      id: this.id,
      className: this.props.className,
      defaultValue: this.props.content
    });
  },

_init: function _init(config, content) {
    var _this = this;

if (this._isInit) {
      this._remove();
    }

// hide the textarea that is me so that no one sees it
    (0, _reactDom.findDOMNode)(this).style.hidden = 'hidden';

var setupCallback = config.setup;
    var hasSetupCallback = typeof setupCallback === 'function';

config.selector = '#' + this.id;
    config.setup = function (editor) {
      EVENTS.forEach(function (event, index) {
        var handler = _this.props[HANDLER_NAMES[index]];
        if (typeof handler !== 'function') return;
        editor.on(event, function (e) {
          // native DOM events don't have access to the editor so we pass it here
          handler(e, editor);
        });
      });
      // need to set content here because the textarea will still have the
      // old `this.props.content`
      if (content) {
        editor.on('init', function () {
          editor.setContent(content);
        });
      }
      if (hasSetupCallback) {
        setupCallback(editor);
      }
    };

tinymce.init(config);

(0, _reactDom.findDOMNode)(this).style.hidden = '';

this._isInit = true;
  },

_remove: function _remove() {
    tinymce.EditorManager.execCommand('mceRemoveEditor', true, this.id);
    this._isInit = false;
  }
});

// add handler propTypes
HANDLER_NAMES.forEach(function (name) {
  TinyMCE.propTypes[name] = _react2['default'].PropTypes.func;
});

module.exports = TinyMCE;

/***/ }),
/* 1282 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = ucFirst;

function ucFirst(str) {
  return str[0].toUpperCase() + str.substring(1);
}

module.exports = exports["default"];

/***/ }),
/* 1283 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var count = 0;
module.exports = function uuid() {
  return 'react-tinymce-' + count++;
};

/***/ }),
/* 1284 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

module.exports = __webpack_require__(1281);

/***/ }),
/* 1285 */
/***/ (function(module, exports) {

/**
 * Copies the values of `source` to `array`.
 *
 * @private
 * @param {Array} source The array to copy values from.
 * @param {Array} [array=[]] The array to copy values to.
 * @returns {Array} Returns `array`.
 */
function arrayCopy(source, array) {
  var index = -1,
      length = source.length;

array || (array = Array(length));
  while (++index < length) {
    array[index] = source[index];
  }
  return array;
}

module.exports = arrayCopy;

/***/ }),
/* 1286 */
/***/ (function(module, exports) {

/**
 * A specialized version of `_.forEach` for arrays without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Array} Returns `array`.
 */
function arrayEach(array, iteratee) {
  var index = -1,
      length = array.length;

while (++index < length) {
    if (iteratee(array[index], index, array) === false) {
      break;
    }
  }
  return array;
}

module.exports = arrayEach;

/***/ }),
/* 1287 */
/***/ (function(module, exports) {

/**
 * A specialized version of `_.some` for arrays without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Array} array The array to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {boolean} Returns `true` if any element passes the predicate check,
 *  else `false`.
 */
function arraySome(array, predicate) {
  var index = -1,
      length = array.length;

while (++index < length) {
    if (predicate(array[index], index, array)) {
      return true;
    }
  }
  return false;
}

module.exports = arraySome;

/***/ }),
/* 1288 */
/***/ (function(module, exports, __webpack_require__) {

var baseCopy = __webpack_require__(1290),
    keys = __webpack_require__(312);

/**
 * The base implementation of `_.assign` without support for argument juggling,
 * multiple sources, and `customizer` functions.
 *
 * @private
 * @param {Object} object The destination object.
 * @param {Object} source The source object.
 * @returns {Object} Returns `object`.
 */
function baseAssign(object, source) {
  return source == null
    ? object
    : baseCopy(source, keys(source), object);
}

module.exports = baseAssign;

/***/ }),
/* 1289 */
/***/ (function(module, exports, __webpack_require__) {

var arrayCopy = __webpack_require__(1285),
    arrayEach = __webpack_require__(1286),
    baseAssign = __webpack_require__(1288),
    baseForOwn = __webpack_require__(1292),
    initCloneArray = __webpack_require__(1302),
    initCloneByTag = __webpack_require__(1303),
    initCloneObject = __webpack_require__(1304),
    isArray = __webpack_require__(190),
    isObject = __webpack_require__(89);

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    objectTag = '[object Object]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    weakMapTag = '[object WeakMap]';

var arrayBufferTag = '[object ArrayBuffer]',
    float32Tag = '[object Float32Array]',
    float64Tag = '[object Float64Array]',
    int8Tag = '[object Int8Array]',
    int16Tag = '[object Int16Array]',
    int32Tag = '[object Int32Array]',
    uint8Tag = '[object Uint8Array]',
    uint8ClampedTag = '[object Uint8ClampedArray]',
    uint16Tag = '[object Uint16Array]',
    uint32Tag = '[object Uint32Array]';

/** Used to identify `toStringTag` values supported by `_.clone`. */
var cloneableTags = {};
cloneableTags[argsTag] = cloneableTags[arrayTag] =
cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =
cloneableTags[dateTag] = cloneableTags[float32Tag] =
cloneableTags[float64Tag] = cloneableTags[int8Tag] =
cloneableTags[int16Tag] = cloneableTags[int32Tag] =
cloneableTags[numberTag] = cloneableTags[objectTag] =
cloneableTags[regexpTag] = cloneableTags[stringTag] =
cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
cloneableTags[errorTag] = cloneableTags[funcTag] =
cloneableTags[mapTag] = cloneableTags[setTag] =
cloneableTags[weakMapTag] = false;

/** Used for native method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/**
 * The base implementation of `_.clone` without support for argument juggling
 * and `this` binding `customizer` functions.
 *
 * @private
 * @param {*} value The value to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @param {Function} [customizer] The function to customize cloning values.
 * @param {string} [key] The key of `value`.
 * @param {Object} [object] The object `value` belongs to.
 * @param {Array} [stackA=[]] Tracks traversed source objects.
 * @param {Array} [stackB=[]] Associates clones with source counterparts.
 * @returns {*} Returns the cloned value.
 */
function baseClone(value, isDeep, customizer, key, object, stackA, stackB) {
  var result;
  if (customizer) {
    result = object ? customizer(value, key, object) : customizer(value);
  }
  if (result !== undefined) {
    return result;
  }
  if (!isObject(value)) {
    return value;
  }
  var isArr = isArray(value);
  if (isArr) {
    result = initCloneArray(value);
    if (!isDeep) {
      return arrayCopy(value, result);
    }
  } else {
    var tag = objToString.call(value),
        isFunc = tag == funcTag;

if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
      result = initCloneObject(isFunc ? {} : value);
      if (!isDeep) {
        return baseAssign(result, value);
      }
    } else {
      return cloneableTags[tag]
        ? initCloneByTag(value, tag, isDeep)
        : (object ? value : {});
    }
  }
  // Check for circular references and return its corresponding clone.
  stackA || (stackA = []);
  stackB || (stackB = []);

var length = stackA.length;
  while (length--) {
    if (stackA[length] == value) {
      return stackB[length];
    }
  }
  // Add the source value to the stack of traversed objects and associate it with its clone.
  stackA.push(value);
  stackB.push(result);

// Recursively populate clone (susceptible to call stack limits).
  (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {
    result[key] = baseClone(subValue, isDeep, customizer, key, value, stackA, stackB);
  });
  return result;
}

module.exports = baseClone;

/***/ }),
/* 1290 */
/***/ (function(module, exports) {

/**
 * Copies properties of `source` to `object`.
 *
 * @private
 * @param {Object} source The object to copy properties from.
 * @param {Array} props The property names to copy.
 * @param {Object} [object={}] The object to copy properties to.
 * @returns {Object} Returns `object`.
 */
function baseCopy(source, props, object) {
  object || (object = {});

var index = -1,
      length = props.length;

while (++index < length) {
    var key = props[index];
    object[key] = source[key];
  }
  return object;
}

module.exports = baseCopy;

/***/ }),
/* 1291 */
/***/ (function(module, exports, __webpack_require__) {

var createBaseFor = __webpack_require__(1297);

/**
 * The base implementation of `baseForIn` and `baseForOwn` which iterates
 * over `object` properties returned by `keysFunc` invoking `iteratee` for
 * each property. Iteratee functions may exit iteration early by explicitly
 * returning `false`.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @param {Function} keysFunc The function to get the keys of `object`.
 * @returns {Object} Returns `object`.
 */
var baseFor = createBaseFor();

module.exports = baseFor;

/***/ }),
/* 1292 */
/***/ (function(module, exports, __webpack_require__) {

var baseFor = __webpack_require__(1291),
    keys = __webpack_require__(312);

/**
 * The base implementation of `_.forOwn` without support for callback
 * shorthands and `this` binding.
 *
 * @private
 * @param {Object} object The object to iterate over.
 * @param {Function} iteratee The function invoked per iteration.
 * @returns {Object} Returns `object`.
 */
function baseForOwn(object, iteratee) {
  return baseFor(object, iteratee, keys);
}

module.exports = baseForOwn;

/***/ }),
/* 1293 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsEqualDeep = __webpack_require__(1294),
    isObject = __webpack_require__(89),
    isObjectLike = __webpack_require__(143);

/**
 * The base implementation of `_.isEqual` without support for `this` binding
 * `customizer` functions.
 *
 * @private
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @param {Function} [customizer] The function to customize comparing values.
 * @param {boolean} [isLoose] Specify performing partial comparisons.
 * @param {Array} [stackA] Tracks traversed `value` objects.
 * @param {Array} [stackB] Tracks traversed `other` objects.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 */
function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {
  if (value === other) {
    return true;
  }
  if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
    return value !== value && other !== other;
  }
  return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);
}

module.exports = baseIsEqual;

/***/ }),
/* 1294 */
/***/ (function(module, exports, __webpack_require__) {

var equalArrays = __webpack_require__(1298),
    equalByTag = __webpack_require__(1299),
    equalObjects = __webpack_require__(1300),
    isArray = __webpack_require__(190),
    isTypedArray = __webpack_require__(1312);

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    objectTag = '[object Object]';

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/**
 * A specialized version of `baseIsEqual` for arrays and objects which performs
 * deep comparisons and tracks traversed objects enabling objects with circular
 * references to be compared.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} [customizer] The function to customize comparing objects.
 * @param {boolean} [isLoose] Specify performing partial comparisons.
 * @param {Array} [stackA=[]] Tracks traversed `value` objects.
 * @param {Array} [stackB=[]] Tracks traversed `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
  var objIsArr = isArray(object),
      othIsArr = isArray(other),
      objTag = arrayTag,
      othTag = arrayTag;

if (!objIsArr) {
    objTag = objToString.call(object);
    if (objTag == argsTag) {
      objTag = objectTag;
    } else if (objTag != objectTag) {
      objIsArr = isTypedArray(object);
    }
  }
  if (!othIsArr) {
    othTag = objToString.call(other);
    if (othTag == argsTag) {
      othTag = objectTag;
    } else if (othTag != objectTag) {
      othIsArr = isTypedArray(other);
    }
  }
  var objIsObj = objTag == objectTag,
      othIsObj = othTag == objectTag,
      isSameTag = objTag == othTag;

if (isSameTag && !(objIsArr || objIsObj)) {
    return equalByTag(object, other, objTag);
  }
  if (!isLoose) {
    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

if (objIsWrapped || othIsWrapped) {
      return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);
    }
  }
  if (!isSameTag) {
    return false;
  }
  // Assume cyclic values are equal.
  // For more information on detecting circular references see https://es5.github.io/#JO.
  stackA || (stackA = []);
  stackB || (stackB = []);

var length = stackA.length;
  while (length--) {
    if (stackA[length] == object) {
      return stackB[length] == other;
    }
  }
  // Add `object` and `other` to the stack of traversed objects.
  stackA.push(object);
  stackB.push(other);

var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);

stackA.pop();
  stackB.pop();

return result;
}

module.exports = baseIsEqualDeep;

/***/ }),
/* 1295 */
/***/ (function(module, exports) {

/**
 * The base implementation of `_.property` without support for deep paths.
 *
 * @private
 * @param {string} key The key of the property to get.
 * @returns {Function} Returns the new function.
 */
function baseProperty(key) {
  return function(object) {
    return object == null ? undefined : object[key];
  };
}

module.exports = baseProperty;

/***/ }),
/* 1296 */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {/** Native method references. */
var ArrayBuffer = global.ArrayBuffer,
    Uint8Array = global.Uint8Array;

/**
 * Creates a clone of the given array buffer.
 *
 * @private
 * @param {ArrayBuffer} buffer The array buffer to clone.
 * @returns {ArrayBuffer} Returns the cloned array buffer.
 */
function bufferClone(buffer) {
  var result = new ArrayBuffer(buffer.byteLength),
      view = new Uint8Array(result);

view.set(new Uint8Array(buffer));
  return result;
}

module.exports = bufferClone;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(29)))

/***/ }),
/* 1297 */
/***/ (function(module, exports, __webpack_require__) {

var toObject = __webpack_require__(1307);

/**
 * Creates a base function for `_.forIn` or `_.forInRight`.
 *
 * @private
 * @param {boolean} [fromRight] Specify iterating from right to left.
 * @returns {Function} Returns the new base function.
 */
function createBaseFor(fromRight) {
  return function(object, iteratee, keysFunc) {
    var iterable = toObject(object),
        props = keysFunc(object),
        length = props.length,
        index = fromRight ? length : -1;

while ((fromRight ? index-- : ++index < length)) {
      var key = props[index];
      if (iteratee(iterable[key], key, iterable) === false) {
        break;
      }
    }
    return object;
  };
}

module.exports = createBaseFor;

/***/ }),
/* 1298 */
/***/ (function(module, exports, __webpack_require__) {

var arraySome = __webpack_require__(1287);

/**
 * A specialized version of `baseIsEqualDeep` for arrays with support for
 * partial deep comparisons.
 *
 * @private
 * @param {Array} array The array to compare.
 * @param {Array} other The other array to compare.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} [customizer] The function to customize comparing arrays.
 * @param {boolean} [isLoose] Specify performing partial comparisons.
 * @param {Array} [stackA] Tracks traversed `value` objects.
 * @param {Array} [stackB] Tracks traversed `other` objects.
 * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
 */
function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {
  var index = -1,
      arrLength = array.length,
      othLength = other.length;

if (arrLength != othLength && !(isLoose && othLength > arrLength)) {
    return false;
  }
  // Ignore non-index properties.
  while (++index < arrLength) {
    var arrValue = array[index],
        othValue = other[index],
        result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;

if (result !== undefined) {
      if (result) {
        continue;
      }
      return false;
    }
    // Recursively compare arrays (susceptible to call stack limits).
    if (isLoose) {
      if (!arraySome(other, function(othValue) {
            return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);
          })) {
        return false;
      }
    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {
      return false;
    }
  }
  return true;
}

module.exports = equalArrays;

/***/ }),
/* 1299 */
/***/ (function(module, exports) {

/** `Object#toString` result references. */
var boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    numberTag = '[object Number]',
    regexpTag = '[object RegExp]',
    stringTag = '[object String]';

/**
 * A specialized version of `baseIsEqualDeep` for comparing objects of
 * the same `toStringTag`.
 *
 * **Note:** This function only supports comparing values with tags of
 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {string} tag The `toStringTag` of the objects to compare.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalByTag(object, other, tag) {
  switch (tag) {
    case boolTag:
    case dateTag:
      // Coerce dates and booleans to numbers, dates to milliseconds and booleans
      // to `1` or `0` treating invalid dates coerced to `NaN` as not equal.
      return +object == +other;

case errorTag:
      return object.name == other.name && object.message == other.message;

case numberTag:
      // Treat `NaN` vs. `NaN` as equal.
      return (object != +object)
        ? other != +other
        : object == +other;

case regexpTag:
    case stringTag:
      // Coerce regexes to strings and treat strings primitives and string
      // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.
      return object == (other + '');
  }
  return false;
}

module.exports = equalByTag;

/***/ }),
/* 1300 */
/***/ (function(module, exports, __webpack_require__) {

var keys = __webpack_require__(312);

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * A specialized version of `baseIsEqualDeep` for objects with support for
 * partial deep comparisons.
 *
 * @private
 * @param {Object} object The object to compare.
 * @param {Object} other The other object to compare.
 * @param {Function} equalFunc The function to determine equivalents of values.
 * @param {Function} [customizer] The function to customize comparing values.
 * @param {boolean} [isLoose] Specify performing partial comparisons.
 * @param {Array} [stackA] Tracks traversed `value` objects.
 * @param {Array} [stackB] Tracks traversed `other` objects.
 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
 */
function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {
  var objProps = keys(object),
      objLength = objProps.length,
      othProps = keys(other),
      othLength = othProps.length;

if (objLength != othLength && !isLoose) {
    return false;
  }
  var index = objLength;
  while (index--) {
    var key = objProps[index];
    if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {
      return false;
    }
  }
  var skipCtor = isLoose;
  while (++index < objLength) {
    key = objProps[index];
    var objValue = object[key],
        othValue = other[key],
        result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;

// Recursively compare objects (susceptible to call stack limits).
    if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {
      return false;
    }
    skipCtor || (skipCtor = key == 'constructor');
  }
  if (!skipCtor) {
    var objCtor = object.constructor,
        othCtor = other.constructor;

module.exports = equalObjects;

/***/ }),
/* 1301 */
/***/ (function(module, exports, __webpack_require__) {

var baseProperty = __webpack_require__(1295);

/**
 * Gets the "length" property value of `object`.
 *
 * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
 * that affects Safari on at least iOS 8.1-8.3 ARM64.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {*} Returns the "length" value.
 */
var getLength = baseProperty('length');

module.exports = getLength;

/***/ }),
/* 1302 */
/***/ (function(module, exports) {

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

// Add array properties assigned by `RegExp#exec`.
  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
    result.index = array.index;
    result.input = array.input;
  }
  return result;
}

module.exports = initCloneArray;

/***/ }),
/* 1303 */
/***/ (function(module, exports, __webpack_require__) {

var bufferClone = __webpack_require__(1296);

/** `Object#toString` result references. */
var boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    numberTag = '[object Number]',
    regexpTag = '[object RegExp]',
    stringTag = '[object String]';

/** Used to match `RegExp` flags from their coerced string values. */
var reFlags = /\w*$/;

/**
 * Initializes an object clone based on its `toStringTag`.
 *
 * **Note:** This function only supports cloning values with tags of
 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
 *
 * @private
 * @param {Object} object The object to clone.
 * @param {string} tag The `toStringTag` of the object to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @returns {Object} Returns the initialized clone.
 */
function initCloneByTag(object, tag, isDeep) {
  var Ctor = object.constructor;
  switch (tag) {
    case arrayBufferTag:
      return bufferClone(object);

case boolTag:
    case dateTag:
      return new Ctor(+object);

case float32Tag: case float64Tag:
    case int8Tag: case int16Tag: case int32Tag:
    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
      var buffer = object.buffer;
      return new Ctor(isDeep ? bufferClone(buffer) : buffer, object.byteOffset, object.length);

case numberTag:
    case stringTag:
      return new Ctor(object);

case regexpTag:
      var result = new Ctor(object.source, reFlags.exec(object));
      result.lastIndex = object.lastIndex;
  }
  return result;
}

module.exports = initCloneByTag;

/***/ }),
/* 1304 */
/***/ (function(module, exports) {

/**
 * Initializes an object clone.
 *
 * @private
 * @param {Object} object The object to clone.
 * @returns {Object} Returns the initialized clone.
 */
function initCloneObject(object) {
  var Ctor = object.constructor;
  if (!(typeof Ctor == 'function' && Ctor instanceof Ctor)) {
    Ctor = Object;
  }
  return new Ctor;
}

module.exports = initCloneObject;

/***/ }),
/* 1305 */
/***/ (function(module, exports, __webpack_require__) {

var isArrayLike = __webpack_require__(310),
    isIndex = __webpack_require__(311),
    isObject = __webpack_require__(89);

/**
 * Checks if the provided arguments are from an iteratee call.
 *
 * @private
 * @param {*} value The potential iteratee value argument.
 * @param {*} index The potential iteratee index or key argument.
 * @param {*} object The potential iteratee object argument.
 * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.
 */
function isIterateeCall(value, index, object) {
  if (!isObject(object)) {
    return false;
  }
  var type = typeof index;
  if (type == 'number'
      ? (isArrayLike(object) && isIndex(index, object.length))
      : (type == 'string' && index in object)) {
    var other = object[index];
    return value === value ? (value === other) : (other !== other);
  }
  return false;
}

module.exports = isIterateeCall;

/***/ }),
/* 1306 */
/***/ (function(module, exports, __webpack_require__) {

var isArguments = __webpack_require__(503),
    isArray = __webpack_require__(190),
    isIndex = __webpack_require__(311),
    isLength = __webpack_require__(142),
    keysIn = __webpack_require__(1313);

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * A fallback implementation of `Object.keys` which creates an array of the
 * own enumerable property names of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 */
function shimKeys(object) {
  var props = keysIn(object),
      propsLength = props.length,
      length = propsLength && object.length;

var allowIndexes = !!length && isLength(length) &&
    (isArray(object) || isArguments(object));

var index = -1,
      result = [];

while (++index < propsLength) {
    var key = props[index];
    if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
      result.push(key);
    }
  }
  return result;
}

module.exports = shimKeys;

/***/ }),
/* 1307 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(89);

/**
 * Converts `value` to an object if it's not one.
 *
 * @private
 * @param {*} value The value to process.
 * @returns {Object} Returns the object.
 */
function toObject(value) {
  return isObject(value) ? value : Object(value);
}

module.exports = toObject;

/***/ }),
/* 1308 */
/***/ (function(module, exports, __webpack_require__) {

var baseClone = __webpack_require__(1289),
    bindCallback = __webpack_require__(501),
    isIterateeCall = __webpack_require__(1305);

/**
 * Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned,
 * otherwise they are assigned by reference. If `customizer` is provided it's
 * invoked to produce the cloned values. If `customizer` returns `undefined`
 * cloning is handled by the method instead. The `customizer` is bound to
 * `thisArg` and invoked with up to three argument; (value [, index|key, object]).
 *
 * **Note:** This method is loosely based on the
 * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm).
 * The enumerable properties of `arguments` objects and objects created by
 * constructors other than `Object` are cloned to plain `Object` objects. An
 * empty object is returned for uncloneable values such as functions, DOM nodes,
 * Maps, Sets, and WeakMaps.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to clone.
 * @param {boolean} [isDeep] Specify a deep clone.
 * @param {Function} [customizer] The function to customize cloning values.
 * @param {*} [thisArg] The `this` binding of `customizer`.
 * @returns {*} Returns the cloned value.
 * @example
 *
 * var users = [
 *   { 'user': 'barney' },
 *   { 'user': 'fred' }
 * ];
 *
 * var shallow = _.clone(users);
 * shallow[0] === users[0];
 * // => true
 *
 * var deep = _.clone(users, true);
 * deep[0] === users[0];
 * // => false
 *
 * // using a customizer callback
 * var el = _.clone(document.body, function(value) {
 *   if (_.isElement(value)) {
 *     return value.cloneNode(false);
 *   }
 * });
 *
 * el === document.body
 * // => false
 * el.nodeName
 * // => BODY
 * el.childNodes.length;
 * // => 0
 */
function clone(value, isDeep, customizer, thisArg) {
  if (isDeep && typeof isDeep != 'boolean' && isIterateeCall(value, isDeep, customizer)) {
    isDeep = false;
  }
  else if (typeof isDeep == 'function') {
    thisArg = customizer;
    customizer = isDeep;
    isDeep = false;
  }
  return typeof customizer == 'function'
    ? baseClone(value, isDeep, bindCallback(customizer, thisArg, 3))
    : baseClone(value, isDeep);
}

module.exports = clone;

/***/ }),
/* 1309 */
/***/ (function(module, exports, __webpack_require__) {

var baseIsEqual = __webpack_require__(1293),
    bindCallback = __webpack_require__(501);

/**
 * Performs a deep comparison between two values to determine if they are
 * equivalent. If `customizer` is provided it's invoked to compare values.
 * If `customizer` returns `undefined` comparisons are handled by the method
 * instead. The `customizer` is bound to `thisArg` and invoked with up to
 * three arguments: (value, other [, index|key]).
 *
 * **Note:** This method supports comparing arrays, booleans, `Date` objects,
 * numbers, `Object` objects, regexes, and strings. Objects are compared by
 * their own, not inherited, enumerable properties. Functions and DOM nodes
 * are **not** supported. Provide a customizer function to extend support
 * for comparing other values.
 *
 * @static
 * @memberOf _
 * @alias eq
 * @category Lang
 * @param {*} value The value to compare.
 * @param {*} other The other value to compare.
 * @param {Function} [customizer] The function to customize value comparisons.
 * @param {*} [thisArg] The `this` binding of `customizer`.
 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
 * @example
 *
 * var object = { 'user': 'fred' };
 * var other = { 'user': 'fred' };
 *
 * object == other;
 * // => false
 *
 * _.isEqual(object, other);
 * // => true
 *
 * // using a customizer callback
 * var array = ['hello', 'goodbye'];
 * var other = ['hi', 'goodbye'];
 *
 * _.isEqual(array, other, function(value, other) {
 *   if (_.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/)) {
 *     return true;
 *   }
 * });
 * // => true
 */
function isEqual(value, other, customizer, thisArg) {
  customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined;
  var result = customizer ? customizer(value, other) : undefined;
  return  result === undefined ? baseIsEqual(value, other, customizer) : !!result;
}

module.exports = isEqual;

/***/ }),
/* 1310 */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(89);

/** `Object#toString` result references. */
var funcTag = '[object Function]';

/** Used for native method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isFunction(_);
 * // => true
 *
 * _.isFunction(/abc/);
 * // => false
 */
function isFunction(value) {
  // The use of `Object#toString` avoids issues with the `typeof` operator
  // in older versions of Chrome and Safari which return 'function' for regexes
  // and Safari 8 which returns 'object' for typed array constructors.
  return isObject(value) && objToString.call(value) == funcTag;
}

module.exports = isFunction;

/***/ }),
/* 1311 */
/***/ (function(module, exports, __webpack_require__) {

var isFunction = __webpack_require__(1310),
    isObjectLike = __webpack_require__(143);

/** Used to detect host constructors (Safari > 5). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to resolve the decompiled source of functions. */
var fnToString = Function.prototype.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
  fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);

/**
 * Checks if `value` is a native function.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
 * @example
 *
 * _.isNative(Array.prototype.push);
 * // => true
 *
 * _.isNative(_);
 * // => false
 */
function isNative(value) {
  if (value == null) {
    return false;
  }
  if (isFunction(value)) {
    return reIsNative.test(fnToString.call(value));
  }
  return isObjectLike(value) && reIsHostCtor.test(value);
}

module.exports = isNative;

/***/ }),
/* 1312 */
/***/ (function(module, exports, __webpack_require__) {

var isLength = __webpack_require__(142),
    isObjectLike = __webpack_require__(143);

/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
    arrayTag = '[object Array]',
    boolTag = '[object Boolean]',
    dateTag = '[object Date]',
    errorTag = '[object Error]',
    funcTag = '[object Function]',
    mapTag = '[object Map]',
    numberTag = '[object Number]',
    objectTag = '[object Object]',
    regexpTag = '[object RegExp]',
    setTag = '[object Set]',
    stringTag = '[object String]',
    weakMapTag = '[object WeakMap]';

/** Used to identify `toStringTag` values of typed arrays. */
var typedArrayTags = {};
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
typedArrayTags[uint32Tag] = true;
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
typedArrayTags[dateTag] = typedArrayTags[errorTag] =
typedArrayTags[funcTag] = typedArrayTags[mapTag] =
typedArrayTags[numberTag] = typedArrayTags[objectTag] =
typedArrayTags[regexpTag] = typedArrayTags[setTag] =
typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;

/** Used for native method references. */
var objectProto = Object.prototype;

/**
 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
 * of values.
 */
var objToString = objectProto.toString;

/**
 * Checks if `value` is classified as a typed array.
 *
 * @static
 * @memberOf _
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
 * @example
 *
 * _.isTypedArray(new Uint8Array);
 * // => true
 *
 * _.isTypedArray([]);
 * // => false
 */
function isTypedArray(value) {
  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];
}

module.exports = isTypedArray;

/***/ }),
/* 1313 */
/***/ (function(module, exports, __webpack_require__) {

var isArguments = __webpack_require__(503),
    isArray = __webpack_require__(190),
    isIndex = __webpack_require__(311),
    isLength = __webpack_require__(142),
    isObject = __webpack_require__(89);

/** Used for native method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

/**
 * Creates an array of the own and inherited enumerable property names of `object`.
 *
 * **Note:** Non-object values are coerced to objects.
 *
 * @static
 * @memberOf _
 * @category Object
 * @param {Object} object The object to query.
 * @returns {Array} Returns the array of property names.
 * @example
 *
 * function Foo() {
 *   this.a = 1;
 *   this.b = 2;
 * }
 *
 * Foo.prototype.c = 3;
 *
 * _.keysIn(new Foo);
 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
 */
function keysIn(object) {
  if (object == null) {
    return [];
  }
  if (!isObject(object)) {
    object = Object(object);
  }
  var length = object.length;
  length = (length && isLength(length) &&
    (isArray(object) || isArguments(object)) && length) || 0;

var Ctor = object.constructor,
      index = -1,
      isProto = typeof Ctor == 'function' && Ctor.prototype === object,
      result = Array(length),
      skipIndexes = length > 0;

while (++index < length) {
    result[index] = (index + '');
  }
  for (var key in object) {
    if (!(skipIndexes && isIndex(key, length)) &&
        !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
      result.push(key);
    }
  }
  return result;
}

module.exports = keysIn;

/***/ }),
/* 1314 */
/***/ (function(module, exports) {

/**
 * This method returns the first argument provided to it.
 *
 * @static
 * @memberOf _
 * @category Utility
 * @param {*} value Any value.
 * @returns {*} Returns `value`.
 * @example
 *
 * var object = { 'user': 'fred' };
 *
 * _.identity(object) === object;
 * // => true
 */
function identity(value) {
  return value;
}

module.exports = identity;

/***/ }),
/* 1315 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.default = void 0;

var PropTypes = _interopRequireWildcard(__webpack_require__(6));

var _addClass = _interopRequireDefault(__webpack_require__(864));

var _removeClass = _interopRequireDefault(__webpack_require__(866));

var _react = _interopRequireDefault(__webpack_require__(0));

var _Transition = _interopRequireDefault(__webpack_require__(504));

var _PropTypes = __webpack_require__(507);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

var addClass = function addClass(node, classes) {
  return node && classes && classes.split(' ').forEach(function (c) {
    return (0, _addClass.default)(node, c);
  });
};

var removeClass = function removeClass(node, classes) {
  return node && classes && classes.split(' ').forEach(function (c) {
    return (0, _removeClass.default)(node, c);
  });
};
/**
 * A `Transition` component using CSS transitions and animations.
 * It's inspired by the excellent [ng-animate](http://www.nganimate.org/) library.
 *
 * `CSSTransition` applies a pair of class names during the `appear`, `enter`,
 * and `exit` stages of the transition. The first class is applied and then a
 * second "active" class in order to activate the css animation. After the animation,
 * matching `done` class names are applied to persist the animation state.
 *
 * When the `in` prop is toggled to `true` the Component will get
 * the `example-enter` CSS class and the `example-enter-active` CSS class
 * added in the next tick. This is a convention based on the `classNames` prop.
 */

var CSSTransition =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(CSSTransition, _React$Component);

function CSSTransition() {
    var _this;

for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

_this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;

_this.onEnter = function (node, appearing) {
      var _this$getClassNames = _this.getClassNames(appearing ? 'appear' : 'enter'),
          className = _this$getClassNames.className;

_this.removeClasses(node, 'exit');

addClass(node, className);

if (_this.props.onEnter) {
        _this.props.onEnter(node, appearing);
      }
    };

_this.onEntering = function (node, appearing) {
      var _this$getClassNames2 = _this.getClassNames(appearing ? 'appear' : 'enter'),
          activeClassName = _this$getClassNames2.activeClassName;

_this.reflowAndAddClass(node, activeClassName);

if (_this.props.onEntering) {
        _this.props.onEntering(node, appearing);
      }
    };

_this.onEntered = function (node, appearing) {
      var _this$getClassNames3 = _this.getClassNames('enter'),
          doneClassName = _this$getClassNames3.doneClassName;

_this.removeClasses(node, appearing ? 'appear' : 'enter');

addClass(node, doneClassName);

if (_this.props.onEntered) {
        _this.props.onEntered(node, appearing);
      }
    };

_this.onExit = function (node) {
      var _this$getClassNames4 = _this.getClassNames('exit'),
          className = _this$getClassNames4.className;

_this.removeClasses(node, 'appear');

_this.removeClasses(node, 'enter');

addClass(node, className);

if (_this.props.onExit) {
        _this.props.onExit(node);
      }
    };

_this.onExiting = function (node) {
      var _this$getClassNames5 = _this.getClassNames('exit'),
          activeClassName = _this$getClassNames5.activeClassName;

_this.reflowAndAddClass(node, activeClassName);

if (_this.props.onExiting) {
        _this.props.onExiting(node);
      }
    };

_this.onExited = function (node) {
      var _this$getClassNames6 = _this.getClassNames('exit'),
          doneClassName = _this$getClassNames6.doneClassName;

_this.removeClasses(node, 'exit');

addClass(node, doneClassName);

if (_this.props.onExited) {
        _this.props.onExited(node);
      }
    };

_this.getClassNames = function (type) {
      var classNames = _this.props.classNames;
      var className = typeof classNames !== 'string' ? classNames[type] : classNames + '-' + type;
      var activeClassName = typeof classNames !== 'string' ? classNames[type + 'Active'] : className + '-active';
      var doneClassName = typeof classNames !== 'string' ? classNames[type + 'Done'] : className + '-done';
      return {
        className: className,
        activeClassName: activeClassName,
        doneClassName: doneClassName
      };
    };

return _this;
  }

var _proto = CSSTransition.prototype;

_proto.removeClasses = function removeClasses(node, type) {
    var _this$getClassNames7 = this.getClassNames(type),
        className = _this$getClassNames7.className,
        activeClassName = _this$getClassNames7.activeClassName,
        doneClassName = _this$getClassNames7.doneClassName;

className && removeClass(node, className);
    activeClassName && removeClass(node, activeClassName);
    doneClassName && removeClass(node, doneClassName);
  };

_proto.reflowAndAddClass = function reflowAndAddClass(node, className) {
    // This is for to force a repaint,
    // which is necessary in order to transition styles when adding a class name.
    if (className) {
      /* eslint-disable no-unused-expressions */
      node && node.scrollTop;
      /* eslint-enable no-unused-expressions */

addClass(node, className);
    }
  };

_proto.render = function render() {
    var props = _extends({}, this.props);

delete props.classNames;
    return _react.default.createElement(_Transition.default, _extends({}, props, {
      onEnter: this.onEnter,
      onEntered: this.onEntered,
      onEntering: this.onEntering,
      onExit: this.onExit,
      onExiting: this.onExiting,
      onExited: this.onExited
    }));
  };

return CSSTransition;
}(_react.default.Component);

CSSTransition.propTypes = process.env.NODE_ENV !== "production" ? _extends({}, _Transition.default.propTypes, {
  /**
   * The animation classNames applied to the component as it enters, exits or has finished the transition.
   * A single name can be provided and it will be suffixed for each stage: e.g.
   *
   * `classNames="fade"` applies `fade-enter`, `fade-enter-active`, `fade-enter-done`,
   * `fade-exit`, `fade-exit-active`, `fade-exit-done`, `fade-appear`, and `fade-appear-active`.
   * Each individual classNames can also be specified independently like:
   *
   * ```js
   * classNames={{
   *  appear: 'my-appear',
   *  appearActive: 'my-active-appear',
   *  enter: 'my-enter',
   *  enterActive: 'my-active-enter',
   *  enterDone: 'my-done-enter',
   *  exit: 'my-exit',
   *  exitActive: 'my-active-exit',
   *  exitDone: 'my-done-exit',
   * }}
   * ```
   *
   * If you want to set these classes using CSS Modules:
   *
   * ```js
   * import styles from './styles.css';
   * ```
   *
   * you might want to use camelCase in your CSS file, that way could simply spread
   * them instead of listing them one by one:
   *
   * ```js
   * classNames={{ ...styles }}
   * ```
   *
   * @type {string | {
   *  appear?: string,
   *  appearActive?: string,
   *  enter?: string,
   *  enterActive?: string,
   *  enterDone?: string,
   *  exit?: string,
   *  exitActive?: string,
   *  exitDone?: string,
   * }}
   */
  classNames: _PropTypes.classNamesShape,

/**
   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is
   * applied.
   *
   * @type Function(node: HtmlElement, isAppearing: bool)
   */
  onEnter: PropTypes.func,

/**
   * A `<Transition>` callback fired immediately after the 'enter-active' or
   * 'appear-active' class is applied.
   *
   * @type Function(node: HtmlElement, isAppearing: bool)
   */
  onEntering: PropTypes.func,

/**
   * A `<Transition>` callback fired immediately after the 'enter' or
   * 'appear' classes are **removed** and the `done` class is added to the DOM node.
   *
   * @type Function(node: HtmlElement, isAppearing: bool)
   */
  onEntered: PropTypes.func,

/**
   * A `<Transition>` callback fired immediately after the 'exit' class is
   * applied.
   *
   * @type Function(node: HtmlElement)
   */
  onExit: PropTypes.func,

/**
   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.
   *
   * @type Function(node: HtmlElement)
   */
  onExiting: PropTypes.func,

/**
   * A `<Transition>` callback fired immediately after the 'exit' classes
   * are **removed** and the `exit-done` class is added to the DOM node.
   *
   * @type Function(node: HtmlElement)
   */
  onExited: PropTypes.func
}) : {};
var _default = CSSTransition;
exports.default = _default;
module.exports = exports["default"];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1316 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

exports.__esModule = true;
exports.default = void 0;

var _propTypes = _interopRequireDefault(__webpack_require__(6));

var _react = _interopRequireDefault(__webpack_require__(0));

var _reactDom = __webpack_require__(7);

var _TransitionGroup = _interopRequireDefault(__webpack_require__(505));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

/**
 * The `<ReplaceTransition>` component is a specialized `Transition` component
 * that animates between two children.
 *
 * ```jsx
 * <ReplaceTransition in>
 *   <Fade><div>I appear first</div></Fade>
 *   <Fade><div>I replace the above</div></Fade>
 * </ReplaceTransition>
 * ```
 */
var ReplaceTransition =
/*#__PURE__*/
function (_React$Component) {
  _inheritsLoose(ReplaceTransition, _React$Component);

function ReplaceTransition() {
    var _this;

for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
      _args[_key] = arguments[_key];
    }

_this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;

_this.handleEnter = function () {
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }

return _this.handleLifecycle('onEnter', 0, args);
    };

_this.handleEntering = function () {
      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        args[_key3] = arguments[_key3];
      }

return _this.handleLifecycle('onEntering', 0, args);
    };

_this.handleEntered = function () {
      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
        args[_key4] = arguments[_key4];
      }

return _this.handleLifecycle('onEntered', 0, args);
    };

_this.handleExit = function () {
      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
        args[_key5] = arguments[_key5];
      }

return _this.handleLifecycle('onExit', 1, args);
    };

_this.handleExiting = function () {
      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
        args[_key6] = arguments[_key6];
      }

return _this.handleLifecycle('onExiting', 1, args);
    };

_this.handleExited = function () {
      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
        args[_key7] = arguments[_key7];
      }

return _this.handleLifecycle('onExited', 1, args);
    };

return _this;
  }

var _proto = ReplaceTransition.prototype;

_proto.handleLifecycle = function handleLifecycle(handler, idx, originalArgs) {
    var _child$props;

var children = this.props.children;

var child = _react.default.Children.toArray(children)[idx];

if (child.props[handler]) (_child$props = child.props)[handler].apply(_child$props, originalArgs);
    if (this.props[handler]) this.props[handler]((0, _reactDom.findDOMNode)(this));
  };

_proto.render = function render() {
    var _this$props = this.props,
        children = _this$props.children,
        inProp = _this$props.in,
        props = _objectWithoutPropertiesLoose(_this$props, ["children", "in"]);

var _React$Children$toArr = _react.default.Children.toArray(children),
        first = _React$Children$toArr[0],
        second = _React$Children$toArr[1];

delete props.onEnter;
    delete props.onEntering;
    delete props.onEntered;
    delete props.onExit;
    delete props.onExiting;
    delete props.onExited;
    return _react.default.createElement(_TransitionGroup.default, props, inProp ? _react.default.cloneElement(first, {
      key: 'first',
      onEnter: this.handleEnter,
      onEntering: this.handleEntering,
      onEntered: this.handleEntered
    }) : _react.default.cloneElement(second, {
      key: 'second',
      onEnter: this.handleExit,
      onEntering: this.handleExiting,
      onEntered: this.handleExited
    }));
  };

return ReplaceTransition;
}(_react.default.Component);

ReplaceTransition.propTypes = process.env.NODE_ENV !== "production" ? {
  in: _propTypes.default.bool.isRequired,
  children: function children(props, propName) {
    if (_react.default.Children.count(props[propName]) !== 2) return new Error("\"" + propName + "\" must be exactly two transition components.");
    return null;
  }
} : {};
var _default = ReplaceTransition;
exports.default = _default;
module.exports = exports["default"];
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

/***/ }),
/* 1317 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
exports.getChildMapping = getChildMapping;
exports.mergeChildMappings = mergeChildMappings;
exports.getInitialChildMapping = getInitialChildMapping;
exports.getNextChildMapping = getNextChildMapping;

var _react = __webpack_require__(0);

/**
 * Given `this.props.children`, return an object mapping key to child.
 *
 * @param {*} children `this.props.children`
 * @return {object} Mapping of key to child
 */
function getChildMapping(children, mapFn) {
  var mapper = function mapper(child) {
    return mapFn && (0, _react.isValidElement)(child) ? mapFn(child) : child;
  };

function mergeChildMappings(prev, next) {
  prev = prev || {};
  next = next || {};

function getValueForKey(key) {
    return key in next ? next[key] : prev[key];
  } // For each key of `next`, the list of keys to insert before that key in
  // the combined list

var nextKeysPending = Object.create(null);
  var pendingKeys = [];

for (var prevKey in prev) {
    if (prevKey in next) {
      if (pendingKeys.length) {
        nextKeysPending[prevKey] = pendingKeys;
        pendingKeys = [];
      }
    } else {
      pendingKeys.push(prevKey);
    }
  }

var i;
  var childMapping = {};

for (var nextKey in next) {
    if (nextKeysPending[nextKey]) {
      for (i = 0; i < nextKeysPending[nextKey].length; i++) {
        var pendingNextKey = nextKeysPending[nextKey][i];
        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
      }
    }

childMapping[nextKey] = getValueForKey(nextKey);
  } // Finally, add the keys which didn't appear before any key in `next`

for (i = 0; i < pendingKeys.length; i++) {
    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
  }

return childMapping;
}

function getProp(child, prop, props) {
  return props[prop] != null ? props[prop] : child.props[prop];
}

function getInitialChildMapping(props, onExited) {
  return getChildMapping(props.children, function (child) {
    return (0, _react.cloneElement)(child, {
      onExited: onExited.bind(null, child),
      in: true,
      appear: getProp(child, 'appear', props),
      enter: getProp(child, 'enter', props),
      exit: getProp(child, 'exit', props)
    });
  });
}

function getNextChildMapping(nextProps, prevChildMapping, onExited) {
  var nextChildMapping = getChildMapping(nextProps.children);
  var children = mergeChildMappings(prevChildMapping, nextChildMapping);
  Object.keys(children).forEach(function (key) {
    var child = children[key];
    if (!(0, _react.isValidElement)(child)) return;
    var hasPrev = key in prevChildMapping;
    var hasNext = key in nextChildMapping;
    var prevChild = prevChildMapping[key];
    var isLeaving = (0, _react.isValidElement)(prevChild) && !prevChild.props.in; // item is new (entering)

if (hasNext && (!hasPrev || isLeaving)) {
      // console.log('entering', key)
      children[key] = (0, _react.cloneElement)(child, {
        onExited: onExited.bind(null, child),
        in: true,
        exit: getProp(child, 'exit', nextProps),
        enter: getProp(child, 'enter', nextProps)
      });
    } else if (!hasNext && hasPrev && !isLeaving) {
      // item is old (exiting)
      // console.log('leaving', key)
      children[key] = (0, _react.cloneElement)(child, {
        in: false
      });
    } else if (hasNext && hasPrev && (0, _react.isValidElement)(prevChild)) {
      // item hasn't changed transition states
      // copy over the last transition props;
      // console.log('unchanged', key)
      children[key] = (0, _react.cloneElement)(child, {
        onExited: onExited.bind(null, child),
        in: prevChild.props.in,
        exit: getProp(child, 'exit', nextProps),
        enter: getProp(child, 'enter', nextProps)
      });
    }
  });
  return children;
}

/***/ }),
/* 1318 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactAddonsShallowCompare = __webpack_require__(36);

var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * This HOC decorates a virtualized component and responds to arrow-key events by scrolling one row or column at a time.
 */
var ArrowKeyStepper = function (_Component) {
  _inherits(ArrowKeyStepper, _Component);

function ArrowKeyStepper(props, context) {
    _classCallCheck(this, ArrowKeyStepper);

var _this = _possibleConstructorReturn(this, (ArrowKeyStepper.__proto__ || Object.getPrototypeOf(ArrowKeyStepper)).call(this, props, context));

_this.state = {
      scrollToColumn: 0,
      scrollToRow: 0
    };

_this._columnStartIndex = 0;
    _this._columnStopIndex = 0;
    _this._rowStartIndex = 0;
    _this._rowStopIndex = 0;

_this._onKeyDown = _this._onKeyDown.bind(_this);
    _this._onSectionRendered = _this._onSectionRendered.bind(_this);
    return _this;
  }

_createClass(ArrowKeyStepper, [{
    key: 'render',
    value: function render() {
      var _props = this.props;
      var className = _props.className;
      var children = _props.children;
      var _state = this.state;
      var scrollToColumn = _state.scrollToColumn;
      var scrollToRow = _state.scrollToRow;

return _react2.default.createElement(
        'div',
        {
          className: className,
          onKeyDown: this._onKeyDown
        },
        children({
          onSectionRendered: this._onSectionRendered,
          scrollToColumn: scrollToColumn,
          scrollToRow: scrollToRow
        })
      );
    }
  }, {
    key: 'shouldComponentUpdate',
    value: function shouldComponentUpdate(nextProps, nextState) {
      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);
    }
  }, {
    key: '_onKeyDown',
    value: function _onKeyDown(event) {
      var _props2 = this.props;
      var columnCount = _props2.columnCount;
      var rowCount = _props2.rowCount;

// The above cases all prevent default event event behavior.
      // This is to keep the grid from scrolling after the snap-to update.

switch (event.key) {
        case 'ArrowDown':
          event.preventDefault();
          this.setState({
            scrollToRow: Math.min(this._rowStopIndex + 1, rowCount - 1)
          });
          break;
        case 'ArrowLeft':
          event.preventDefault();
          this.setState({
            scrollToColumn: Math.max(this._columnStartIndex - 1, 0)
          });
          break;
        case 'ArrowRight':
          event.preventDefault();
          this.setState({
            scrollToColumn: Math.min(this._columnStopIndex + 1, columnCount - 1)
          });
          break;
        case 'ArrowUp':
          event.preventDefault();
          this.setState({
            scrollToRow: Math.max(this._rowStartIndex - 1, 0)
          });
          break;
      }
    }
  }, {
    key: '_onSectionRendered',
    value: function _onSectionRendered(_ref) {
      var columnStartIndex = _ref.columnStartIndex;
      var columnStopIndex = _ref.columnStopIndex;
      var rowStartIndex = _ref.rowStartIndex;
      var rowStopIndex = _ref.rowStopIndex;

this._columnStartIndex = columnStartIndex;
      this._columnStopIndex = columnStopIndex;
      this._rowStartIndex = rowStartIndex;
      this._rowStopIndex = rowStopIndex;
    }
  }]);

return ArrowKeyStepper;
}(_react.Component);

ArrowKeyStepper.propTypes = {
  children: _react.PropTypes.func.isRequired,
  className: _react.PropTypes.string,
  columnCount: _react.PropTypes.number.isRequired,
  rowCount: _react.PropTypes.number.isRequired
};
exports.default = ArrowKeyStepper;

/***/ }),
/* 1319 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ArrowKeyStepper = exports.default = undefined;

var _ArrowKeyStepper2 = __webpack_require__(1318);

var _ArrowKeyStepper3 = _interopRequireDefault(_ArrowKeyStepper2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _ArrowKeyStepper3.default;
exports.ArrowKeyStepper = _ArrowKeyStepper3.default;

/***/ }),
/* 1320 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactAddonsShallowCompare = __webpack_require__(36);

var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Decorator component that automatically adjusts the width and height of a single child.
 * Child component should not be declared as a child but should rather be specified by a `ChildComponent` property.
 * All other properties will be passed through to the child component.
 */
var AutoSizer = function (_Component) {
  _inherits(AutoSizer, _Component);

function AutoSizer(props) {
    _classCallCheck(this, AutoSizer);

var _this = _possibleConstructorReturn(this, (AutoSizer.__proto__ || Object.getPrototypeOf(AutoSizer)).call(this, props));

_this.state = {
      height: 0,
      width: 0
    };

_this._onResize = _this._onResize.bind(_this);
    _this._setRef = _this._setRef.bind(_this);
    return _this;
  }

_createClass(AutoSizer, [{
    key: 'componentDidMount',
    value: function componentDidMount() {
      // Delay access of parentNode until mount.
      // This handles edge-cases where the component has already been unmounted before its ref has been set,
      // As well as libraries like react-lite which have a slightly different lifecycle.
      this._parentNode = this._autoSizer.parentNode;

// Defer requiring resize handler in order to support server-side rendering.
      // See issue #41
      this._detectElementResize = __webpack_require__(1349);
      this._detectElementResize.addResizeListener(this._parentNode, this._onResize);

this._onResize();
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      if (this._detectElementResize) {
        this._detectElementResize.removeResizeListener(this._parentNode, this._onResize);
      }
    }
  }, {
    key: 'render',
    value: function render() {
      var _props = this.props;
      var children = _props.children;
      var disableHeight = _props.disableHeight;
      var disableWidth = _props.disableWidth;
      var _state = this.state;
      var height = _state.height;
      var width = _state.width;

// Outer div should not force width/height since that may prevent containers from shrinking.
      // Inner component should overflow and use calculated width/height.
      // See issue #68 for more information.

var outerStyle = { overflow: 'visible' };

if (!disableHeight) {
        outerStyle.height = 0;
      }

if (!disableWidth) {
        outerStyle.width = 0;
      }

return _react2.default.createElement(
        'div',
        {
          ref: this._setRef,
          style: outerStyle
        },
        children({ height: height, width: width })
      );
    }
  }, {
    key: 'shouldComponentUpdate',
    value: function shouldComponentUpdate(nextProps, nextState) {
      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);
    }
  }, {
    key: '_onResize',
    value: function _onResize() {
      var onResize = this.props.onResize;

// Gaurd against AutoSizer component being removed from the DOM immediately after being added.
      // This can result in invalid style values which can result in NaN values if we don't handle them.
      // See issue #150 for more context.

var boundingRect = this._parentNode.getBoundingClientRect();
      var height = boundingRect.height || 0;
      var width = boundingRect.width || 0;

var style = getComputedStyle(this._parentNode);
      var paddingLeft = parseInt(style.paddingLeft, 10) || 0;
      var paddingRight = parseInt(style.paddingRight, 10) || 0;
      var paddingTop = parseInt(style.paddingTop, 10) || 0;
      var paddingBottom = parseInt(style.paddingBottom, 10) || 0;

this.setState({
        height: height - paddingTop - paddingBottom,
        width: width - paddingLeft - paddingRight
      });

onResize({ height: height, width: width });
    }
  }, {
    key: '_setRef',
    value: function _setRef(autoSizer) {
      this._autoSizer = autoSizer;
    }
  }]);

return AutoSizer;
}(_react.Component);

AutoSizer.propTypes = {
  /**
   * Function responsible for rendering children.
   * This function should implement the following signature:
   * ({ height, width }) => PropTypes.element
   */
  children: _react.PropTypes.func.isRequired,

/** Disable dynamic :height property */
  disableHeight: _react.PropTypes.bool,

/** Disable dynamic :width property */
  disableWidth: _react.PropTypes.bool,

/** Callback to be invoked on-resize: ({ height, width }) */
  onResize: _react.PropTypes.func.isRequired
};
AutoSizer.defaultProps = {
  onResize: function onResize() {}
};
exports.default = AutoSizer;

/***/ }),
/* 1321 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.AutoSizer = exports.default = undefined;

var _AutoSizer2 = __webpack_require__(1320);

var _AutoSizer3 = _interopRequireDefault(_AutoSizer2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _AutoSizer3.default;
exports.AutoSizer = _AutoSizer3.default;

/***/ }),
/* 1322 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _reactAddonsShallowCompare = __webpack_require__(36);

var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);

var _reactDom = __webpack_require__(7);

var _reactDom2 = _interopRequireDefault(_reactDom);

var _defaultCellSizeCache = __webpack_require__(508);

var _defaultCellSizeCache2 = _interopRequireDefault(_defaultCellSizeCache);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Measures a Grid cell's contents by rendering them in a way that is not visible to the user.
 * Either a fixed width or height may be provided if it is desirable to measure only in one direction.
 */
var CellMeasurer = function (_Component) {
  _inherits(CellMeasurer, _Component);

function CellMeasurer(props, state) {
    _classCallCheck(this, CellMeasurer);

var _this = _possibleConstructorReturn(this, (CellMeasurer.__proto__ || Object.getPrototypeOf(CellMeasurer)).call(this, props, state));

_this._cellSizeCache = props.cellSizeCache || new _defaultCellSizeCache2.default();

_this.getColumnWidth = _this.getColumnWidth.bind(_this);
    _this.getRowHeight = _this.getRowHeight.bind(_this);
    _this.resetMeasurements = _this.resetMeasurements.bind(_this);
    _this.resetMeasurementForColumn = _this.resetMeasurementForColumn.bind(_this);
    _this.resetMeasurementForRow = _this.resetMeasurementForRow.bind(_this);
    return _this;
  }

_createClass(CellMeasurer, [{
    key: 'getColumnWidth',
    value: function getColumnWidth(_ref) {
      var index = _ref.index;

if (this._cellSizeCache.hasColumnWidth(index)) {
        return this._cellSizeCache.getColumnWidth(index);
      }

var rowCount = this.props.rowCount;

var maxWidth = 0;

for (var rowIndex = 0; rowIndex < rowCount; rowIndex++) {
        var _measureCell2 = this._measureCell({
          clientWidth: true,
          columnIndex: index,
          rowIndex: rowIndex
        });

var width = _measureCell2.width;

maxWidth = Math.max(maxWidth, width);
      }

this._cellSizeCache.setColumnWidth(index, maxWidth);

return maxWidth;
    }
  }, {
    key: 'getRowHeight',
    value: function getRowHeight(_ref2) {
      var index = _ref2.index;

if (this._cellSizeCache.hasRowHeight(index)) {
        return this._cellSizeCache.getRowHeight(index);
      }

var columnCount = this.props.columnCount;

var maxHeight = 0;

for (var columnIndex = 0; columnIndex < columnCount; columnIndex++) {
        var _measureCell3 = this._measureCell({
          clientHeight: true,
          columnIndex: columnIndex,
          rowIndex: index
        });

var height = _measureCell3.height;

maxHeight = Math.max(maxHeight, height);
      }

this._cellSizeCache.setRowHeight(index, maxHeight);

return maxHeight;
    }
  }, {
    key: 'resetMeasurementForColumn',
    value: function resetMeasurementForColumn(columnIndex) {
      this._cellSizeCache.clearColumnWidth(columnIndex);
    }
  }, {
    key: 'resetMeasurementForRow',
    value: function resetMeasurementForRow(rowIndex) {
      this._cellSizeCache.clearRowHeight(rowIndex);
    }
  }, {
    key: 'resetMeasurements',
    value: function resetMeasurements() {
      this._cellSizeCache.clearAllColumnWidths();
      this._cellSizeCache.clearAllRowHeights();
    }
  }, {
    key: 'componentDidMount',
    value: function componentDidMount() {
      this._renderAndMount();
    }
  }, {
    key: 'componentWillReceiveProps',
    value: function componentWillReceiveProps(nextProps) {
      var cellSizeCache = this.props.cellSizeCache;

if (cellSizeCache !== nextProps.cellSizeCache) {
        this._cellSizeCache = nextProps.cellSizeCache;
      }

this._updateDivDimensions(nextProps);
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      this._unmountContainer();
    }
  }, {
    key: 'render',
    value: function render() {
      var children = this.props.children;

return children({
        getColumnWidth: this.getColumnWidth,
        getRowHeight: this.getRowHeight,
        resetMeasurements: this.resetMeasurements,
        resetMeasurementForColumn: this.resetMeasurementForColumn,
        resetMeasurementForRow: this.resetMeasurementForRow
      });
    }
  }, {
    key: 'shouldComponentUpdate',
    value: function shouldComponentUpdate(nextProps, nextState) {
      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);
    }
  }, {
    key: '_getContainerNode',
    value: function _getContainerNode(props) {
      var container = props.container;

if (container) {
        return _reactDom2.default.findDOMNode(typeof container === 'function' ? container() : container);
      } else {
        return document.body;
      }
    }
  }, {
    key: '_measureCell',
    value: function _measureCell(_ref3) {
      var _ref3$clientHeight = _ref3.clientHeight;
      var clientHeight = _ref3$clientHeight === undefined ? false : _ref3$clientHeight;
      var _ref3$clientWidth = _ref3.clientWidth;
      var clientWidth = _ref3$clientWidth === undefined ? true : _ref3$clientWidth;
      var columnIndex = _ref3.columnIndex;
      var rowIndex = _ref3.rowIndex;
      var cellRenderer = this.props.cellRenderer;

var rendered = cellRenderer({
        columnIndex: columnIndex,
        rowIndex: rowIndex
      });

// Handle edge case where this method is called before the CellMeasurer has completed its initial render (and mounted).
      this._renderAndMount();

// @TODO Keep an eye on this for future React updates as the interface may change:
      // https://twitter.com/soprano/status/737316379712331776
      _reactDom2.default.unstable_renderSubtreeIntoContainer(this, rendered, this._div);

var measurements = {
        height: clientHeight && this._div.clientHeight,
        width: clientWidth && this._div.clientWidth
      };

_reactDom2.default.unmountComponentAtNode(this._div);

return measurements;
    }
  }, {
    key: '_renderAndMount',
    value: function _renderAndMount() {
      if (!this._div) {
        this._div = document.createElement('div');
        this._div.style.display = 'inline-block';
        this._div.style.position = 'absolute';
        this._div.style.visibility = 'hidden';
        this._div.style.zIndex = -1;

this._updateDivDimensions(this.props);

this._containerNode = this._getContainerNode(this.props);
        this._containerNode.appendChild(this._div);
      }
    }
  }, {
    key: '_unmountContainer',
    value: function _unmountContainer() {
      if (this._div) {
        this._containerNode.removeChild(this._div);

this._div = null;
      }

this._containerNode = null;
    }
  }, {
    key: '_updateDivDimensions',
    value: function _updateDivDimensions(props) {
      var height = props.height;
      var width = props.width;

if (height && height !== this._divHeight) {
        this._divHeight = height;
        this._div.style.height = height + 'px';
      }

if (width && width !== this._divWidth) {
        this._divWidth = width;
        this._div.style.width = width + 'px';
      }
    }
  }]);

return CellMeasurer;
}(_react.Component);

CellMeasurer.propTypes = {
  /**
   * Renders a cell given its indices.
   * Should implement the following interface: ({ columnIndex: number, rowIndex: number }): PropTypes.node
   */
  cellRenderer: _react.PropTypes.func.isRequired,

/**
   * Optional, custom caching strategy for cell sizes.
   */
  cellSizeCache: _react.PropTypes.object,

/**
   * Function responsible for rendering a virtualized component.
   * This function should implement the following signature:
   * ({ getColumnWidth, getRowHeight, resetMeasurements }) => PropTypes.element
   */
  children: _react.PropTypes.func.isRequired,

/**
   * Number of columns in grid.
   */
  columnCount: _react.PropTypes.number.isRequired,

/**
   * A Node, Component instance, or function that returns either.
   * If this property is not specified the document body will be used.
   */
  container: _react2.default.PropTypes.oneOfType([_react2.default.PropTypes.func, _react2.default.PropTypes.node]),

/**
   * Assign a fixed :height in order to measure dynamic text :width only.
   */
  height: _react.PropTypes.number,

/**
   * Number of rows in grid.
   */
  rowCount: _react.PropTypes.number.isRequired,

/**
   * Assign a fixed :width in order to measure dynamic text :height only.
   */
  width: _react.PropTypes.number
};
exports.default = CellMeasurer;

/***/ }),
/* 1323 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.defaultCellSizeCache = exports.CellMeasurer = exports.default = undefined;

var _CellMeasurer2 = __webpack_require__(1322);

var _CellMeasurer3 = _interopRequireDefault(_CellMeasurer2);

var _defaultCellSizeCache2 = __webpack_require__(508);

var _defaultCellSizeCache3 = _interopRequireDefault(_defaultCellSizeCache2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _CellMeasurer3.default;
exports.CellMeasurer = _CellMeasurer3.default;
exports.defaultCellSizeCache = _defaultCellSizeCache3.default;

/***/ }),
/* 1324 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _CollectionView = __webpack_require__(1325);

var _CollectionView2 = _interopRequireDefault(_CollectionView);

var _calculateSizeAndPositionData2 = __webpack_require__(1329);

var _calculateSizeAndPositionData3 = _interopRequireDefault(_calculateSizeAndPositionData2);

var _getUpdatedOffsetForIndex = __webpack_require__(1348);

var _getUpdatedOffsetForIndex2 = _interopRequireDefault(_getUpdatedOffsetForIndex);

var _reactAddonsShallowCompare = __webpack_require__(36);

var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Renders scattered or non-linear data.
 * Unlike Grid, which renders checkerboard data, Collection can render arbitrarily positioned- even overlapping- data.
 */
var Collection = function (_Component) {
  _inherits(Collection, _Component);

function Collection(props, context) {
    _classCallCheck(this, Collection);

var _this = _possibleConstructorReturn(this, (Collection.__proto__ || Object.getPrototypeOf(Collection)).call(this, props, context));

_this._cellMetadata = [];
    _this._lastRenderedCellIndices = [];

// Cell cache during scroll (for perforamnce)
    _this._cellCache = [];

_this._isScrollingChange = _this._isScrollingChange.bind(_this);
    return _this;
  }

/** See Collection#recomputeCellSizesAndPositions */

_createClass(Collection, [{
    key: 'recomputeCellSizesAndPositions',
    value: function recomputeCellSizesAndPositions() {
      this._cellCache = [];
      this._collectionView.recomputeCellSizesAndPositions();
    }

/** React lifecycle methods */

}, {
    key: 'render',
    value: function render() {
      var _this2 = this;

var props = _objectWithoutProperties(this.props, []);

return _react2.default.createElement(_CollectionView2.default, _extends({
        cellLayoutManager: this,
        isScrollingChange: this._isScrollingChange,
        ref: function ref(_ref) {
          _this2._collectionView = _ref;
        }
      }, props));
    }
  }, {
    key: 'shouldComponentUpdate',
    value: function shouldComponentUpdate(nextProps, nextState) {
      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);
    }

/** CellLayoutManager interface */

}, {
    key: 'calculateSizeAndPositionData',
    value: function calculateSizeAndPositionData() {
      var _props = this.props;
      var cellCount = _props.cellCount;
      var cellSizeAndPositionGetter = _props.cellSizeAndPositionGetter;
      var sectionSize = _props.sectionSize;

var data = (0, _calculateSizeAndPositionData3.default)({
        cellCount: cellCount,
        cellSizeAndPositionGetter: cellSizeAndPositionGetter,
        sectionSize: sectionSize
      });

this._cellMetadata = data.cellMetadata;
      this._sectionManager = data.sectionManager;
      this._height = data.height;
      this._width = data.width;
    }

/**
     * Returns the most recently rendered set of cell indices.
     */

}, {
    key: 'getLastRenderedIndices',
    value: function getLastRenderedIndices() {
      return this._lastRenderedCellIndices;
    }

/**
     * Calculates the minimum amount of change from the current scroll position to ensure the specified cell is (fully) visible.
     */

}, {
    key: 'getScrollPositionForCell',
    value: function getScrollPositionForCell(_ref2) {
      var align = _ref2.align;
      var cellIndex = _ref2.cellIndex;
      var height = _ref2.height;
      var scrollLeft = _ref2.scrollLeft;
      var scrollTop = _ref2.scrollTop;
      var width = _ref2.width;
      var cellCount = this.props.cellCount;

if (cellIndex >= 0 && cellIndex < cellCount) {
        var cellMetadata = this._cellMetadata[cellIndex];

scrollLeft = (0, _getUpdatedOffsetForIndex2.default)({
          align: align,
          cellOffset: cellMetadata.x,
          cellSize: cellMetadata.width,
          containerSize: width,
          currentOffset: scrollLeft,
          targetIndex: cellIndex
        });

scrollTop = (0, _getUpdatedOffsetForIndex2.default)({
          align: align,
          cellOffset: cellMetadata.y,
          cellSize: cellMetadata.height,
          containerSize: height,
          currentOffset: scrollTop,
          targetIndex: cellIndex
        });
      }

return {
        scrollLeft: scrollLeft,
        scrollTop: scrollTop
      };
    }
  }, {
    key: 'getTotalSize',
    value: function getTotalSize() {
      return {
        height: this._height,
        width: this._width
      };
    }
  }, {
    key: 'cellRenderers',
    value: function cellRenderers(_ref3) {
      var _this3 = this;

var height = _ref3.height;
      var isScrolling = _ref3.isScrolling;
      var width = _ref3.width;
      var x = _ref3.x;
      var y = _ref3.y;
      var _props2 = this.props;
      var cellGroupRenderer = _props2.cellGroupRenderer;
      var cellRenderer = _props2.cellRenderer;

// Store for later calls to getLastRenderedIndices()

this._lastRenderedCellIndices = this._sectionManager.getCellIndices({
        height: height,
        width: width,
        x: x,
        y: y
      });

return cellGroupRenderer({
        cellCache: this._cellCache,
        cellRenderer: cellRenderer,
        cellSizeAndPositionGetter: function cellSizeAndPositionGetter(_ref4) {
          var index = _ref4.index;
          return _this3._sectionManager.getCellMetadata({ index: index });
        },
        indices: this._lastRenderedCellIndices,
        isScrolling: isScrolling
      });
    }
  }, {
    key: '_isScrollingChange',
    value: function _isScrollingChange(isScrolling) {
      if (!isScrolling) {
        this._cellCache = [];
      }
    }
  }]);

return Collection;
}(_react.Component);

Collection.propTypes = {
  'aria-label': _react.PropTypes.string,

/**
   * Number of cells in Collection.
   */
  cellCount: _react.PropTypes.number.isRequired,

/**
   * Responsible for rendering a group of cells given their indices.
   * Should implement the following interface: ({
   *   cellSizeAndPositionGetter:Function,
   *   indices: Array<number>,
   *   cellRenderer: Function
   * }): Array<PropTypes.node>
   */
  cellGroupRenderer: _react.PropTypes.func.isRequired,

/**
   * Responsible for rendering a cell given an row and column index.
   * Should implement the following interface: ({ index: number, key: string, style: object }): PropTypes.element
   */
  cellRenderer: _react.PropTypes.func.isRequired,

/**
   * Callback responsible for returning size and offset/position information for a given cell (index).
   * ({ index: number }): { height: number, width: number, x: number, y: number }
   */
  cellSizeAndPositionGetter: _react.PropTypes.func.isRequired,

/**
   * Optionally override the size of the sections a Collection's cells are split into.
   */
  sectionSize: _react.PropTypes.number
};
Collection.defaultProps = {
  'aria-label': 'grid',
  cellGroupRenderer: defaultCellGroupRenderer
};
exports.default = Collection;

function defaultCellGroupRenderer(_ref5) {
  var cellCache = _ref5.cellCache;
  var cellRenderer = _ref5.cellRenderer;
  var cellSizeAndPositionGetter = _ref5.cellSizeAndPositionGetter;
  var indices = _ref5.indices;
  var isScrolling = _ref5.isScrolling;

return indices.map(function (index) {
    var cellMetadata = cellSizeAndPositionGetter({ index: index });

var cellRendererProps = {
      index: index,
      isScrolling: isScrolling,
      key: index,
      style: {
        height: cellMetadata.height,
        left: cellMetadata.x,
        position: 'absolute',
        top: cellMetadata.y,
        width: cellMetadata.width
      }
    };

// Avoid re-creating cells while scrolling.
    // This can lead to the same cell being created many times and can cause performance issues for "heavy" cells.
    // If a scroll is in progress- cache and reuse cells.
    // This cache will be thrown away once scrolling complets.
    if (isScrolling) {
      if (!(index in cellCache)) {
        cellCache[index] = cellRenderer(cellRendererProps);
      }

return cellCache[index];
    } else {
      return cellRenderer(cellRendererProps);
    }
  }).filter(function (renderedCell) {
    return !!renderedCell;
  });
}

/***/ }),
/* 1325 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _createCallbackMemoizer = __webpack_require__(315);

var _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer);

var _scrollbarSize = __webpack_require__(316);

var _scrollbarSize2 = _interopRequireDefault(_scrollbarSize);

var _reactAddonsShallowCompare = __webpack_require__(36);

var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// @TODO It would be nice to refactor Grid to use this code as well.

/**
 * Monitors changes in properties (eg. cellCount) and state (eg. scroll offsets) to determine when rendering needs to occur.
 * This component does not render any visible content itself; it defers to the specified :cellLayoutManager.
 */

var CollectionView = function (_Component) {
  _inherits(CollectionView, _Component);

function CollectionView(props, context) {
    _classCallCheck(this, CollectionView);

var _this = _possibleConstructorReturn(this, (CollectionView.__proto__ || Object.getPrototypeOf(CollectionView)).call(this, props, context));

_this.state = {
      calculateSizeAndPositionDataOnNextUpdate: false,
      isScrolling: false,
      scrollLeft: 0,
      scrollTop: 0
    };

// Invokes callbacks only when their values have changed.
    _this._onSectionRenderedMemoizer = (0, _createCallbackMemoizer2.default)();
    _this._onScrollMemoizer = (0, _createCallbackMemoizer2.default)(false);

// Bind functions to instance so they don't lose context when passed around.
    _this._invokeOnSectionRenderedHelper = _this._invokeOnSectionRenderedHelper.bind(_this);
    _this._onScroll = _this._onScroll.bind(_this);
    _this._updateScrollPositionForScrollToCell = _this._updateScrollPositionForScrollToCell.bind(_this);
    return _this;
  }

/**
   * Forced recompute of cell sizes and positions.
   * This function should be called if cell sizes have changed but nothing else has.
   * Since cell positions are calculated by callbacks, the collection view has no way of detecting when the underlying data has changed.
   */

_createClass(CollectionView, [{
    key: 'recomputeCellSizesAndPositions',
    value: function recomputeCellSizesAndPositions() {
      this.setState({
        calculateSizeAndPositionDataOnNextUpdate: true
      });
    }

/* ---------------------------- Component lifecycle methods ---------------------------- */

}, {
    key: 'componentDidMount',
    value: function componentDidMount() {
      var _props = this.props;
      var cellLayoutManager = _props.cellLayoutManager;
      var scrollLeft = _props.scrollLeft;
      var scrollToCell = _props.scrollToCell;
      var scrollTop = _props.scrollTop;

// If this component was first rendered server-side, scrollbar size will be undefined.
      // In that event we need to remeasure.

if (!this._scrollbarSizeMeasured) {
        this._scrollbarSize = (0, _scrollbarSize2.default)();
        this._scrollbarSizeMeasured = true;
        this.setState({});
      }

if (scrollToCell >= 0) {
        this._updateScrollPositionForScrollToCell();
      } else if (scrollLeft >= 0 || scrollTop >= 0) {
        this._setScrollPosition({ scrollLeft: scrollLeft, scrollTop: scrollTop });
      }

// Update onSectionRendered callback.
      this._invokeOnSectionRenderedHelper();

var _cellLayoutManager$ge = cellLayoutManager.getTotalSize();

var totalHeight = _cellLayoutManager$ge.height;
      var totalWidth = _cellLayoutManager$ge.width;

// Initialize onScroll callback.

this._invokeOnScrollMemoizer({
        scrollLeft: scrollLeft || 0,
        scrollTop: scrollTop || 0,
        totalHeight: totalHeight,
        totalWidth: totalWidth
      });
    }
  }, {
    key: 'componentDidUpdate',
    value: function componentDidUpdate(prevProps, prevState) {
      var _props2 = this.props;
      var height = _props2.height;
      var scrollToCell = _props2.scrollToCell;
      var width = _props2.width;
      var _state = this.state;
      var scrollLeft = _state.scrollLeft;
      var scrollPositionChangeReason = _state.scrollPositionChangeReason;
      var scrollToAlignment = _state.scrollToAlignment;
      var scrollTop = _state.scrollTop;

if (scrollPositionChangeReason === SCROLL_POSITION_CHANGE_REASONS.REQUESTED) {
        if (scrollLeft >= 0 && scrollLeft !== prevState.scrollLeft && scrollLeft !== this._scrollingContainer.scrollLeft) {
          this._scrollingContainer.scrollLeft = scrollLeft;
        }
        if (scrollTop >= 0 && scrollTop !== prevState.scrollTop && scrollTop !== this._scrollingContainer.scrollTop) {
          this._scrollingContainer.scrollTop = scrollTop;
        }
      }

// Update scroll offsets if the current :scrollToCell values requires it
      if (height !== prevProps.height || scrollToAlignment !== prevProps.scrollToAlignment || scrollToCell !== prevProps.scrollToCell || width !== prevProps.width) {
        this._updateScrollPositionForScrollToCell();
      }

// Update onRowsRendered callback if start/stop indices have changed
      this._invokeOnSectionRenderedHelper();
    }
  }, {
    key: 'componentWillMount',
    value: function componentWillMount() {
      var cellLayoutManager = this.props.cellLayoutManager;

cellLayoutManager.calculateSizeAndPositionData();

// If this component is being rendered server-side, getScrollbarSize() will return undefined.
      // We handle this case in componentDidMount()
      this._scrollbarSize = (0, _scrollbarSize2.default)();
      if (this._scrollbarSize === undefined) {
        this._scrollbarSizeMeasured = false;
        this._scrollbarSize = 0;
      } else {
        this._scrollbarSizeMeasured = true;
      }
    }
  }, {
    key: 'componentWillUnmount',
    value: function componentWillUnmount() {
      if (this._disablePointerEventsTimeoutId) {
        clearTimeout(this._disablePointerEventsTimeoutId);
      }
    }

}, {
    key: 'componentWillUpdate',
    value: function componentWillUpdate(nextProps, nextState) {
      if (nextProps.cellCount === 0 && (nextState.scrollLeft !== 0 || nextState.scrollTop !== 0)) {
        this._setScrollPosition({
          scrollLeft: 0,
          scrollTop: 0
        });
      } else if (nextProps.scrollLeft !== this.props.scrollLeft || nextProps.scrollTop !== this.props.scrollTop) {
        this._setScrollPosition({
          scrollLeft: nextProps.scrollLeft,
          scrollTop: nextProps.scrollTop
        });
      }

if (nextProps.cellCount !== this.props.cellCount || nextProps.cellLayoutManager !== this.props.cellLayoutManager || nextState.calculateSizeAndPositionDataOnNextUpdate) {
        nextProps.cellLayoutManager.calculateSizeAndPositionData();
      }

if (nextState.calculateSizeAndPositionDataOnNextUpdate) {
        this.setState({
          calculateSizeAndPositionDataOnNextUpdate: false
        });
      }
    }
  }, {
    key: 'render',
    value: function render() {
      var _this2 = this;

var _props3 = this.props;
      var autoHeight = _props3.autoHeight;
      var cellCount = _props3.cellCount;
      var cellLayoutManager = _props3.cellLayoutManager;
      var className = _props3.className;
      var height = _props3.height;
      var horizontalOverscanSize = _props3.horizontalOverscanSize;
      var noContentRenderer = _props3.noContentRenderer;
      var style = _props3.style;
      var verticalOverscanSize = _props3.verticalOverscanSize;
      var width = _props3.width;
      var _state2 = this.state;
      var isScrolling = _state2.isScrolling;
      var scrollLeft = _state2.scrollLeft;
      var scrollTop = _state2.scrollTop;

var _cellLayoutManager$ge2 = cellLayoutManager.getTotalSize();

var totalHeight = _cellLayoutManager$ge2.height;
      var totalWidth = _cellLayoutManager$ge2.width;

// Safely expand the rendered area by the specified overscan amount

var left = Math.max(0, scrollLeft - horizontalOverscanSize);
      var top = Math.max(0, scrollTop - verticalOverscanSize);
      var right = Math.min(totalWidth, scrollLeft + width + horizontalOverscanSize);
      var bottom = Math.min(totalHeight, scrollTop + height + verticalOverscanSize);

var childrenToDisplay = height > 0 && width > 0 ? cellLayoutManager.cellRenderers({
        height: bottom - top,
        isScrolling: isScrolling,
        width: right - left,
        x: left,
        y: top
      }) : [];

var collectionStyle = {
        boxSizing: 'border-box',
        height: autoHeight ? 'auto' : height,
        overflow: 'auto',
        position: 'relative',
        WebkitOverflowScrolling: 'touch',
        width: width,
        willChange: 'transform'
      };

// Force browser to hide scrollbars when we know they aren't necessary.
      // Otherwise once scrollbars appear they may not disappear again.
      // For more info see issue #116
      var verticalScrollBarSize = totalHeight > height ? this._scrollbarSize : 0;
      var horizontalScrollBarSize = totalWidth > width ? this._scrollbarSize : 0;
      if (totalWidth + verticalScrollBarSize <= width) {
        collectionStyle.overflowX = 'hidden';
      }
      if (totalHeight + horizontalScrollBarSize <= height) {
        collectionStyle.overflowY = 'hidden';
      }

return _react2.default.createElement(
        'div',
        {
          ref: function ref(_ref) {
            _this2._scrollingContainer = _ref;
          },
          'aria-label': this.props['aria-label'],
          className: (0, _classnames2.default)('ReactVirtualized__Collection', className),
          onScroll: this._onScroll,
          role: 'grid',
          style: _extends({}, collectionStyle, style),
          tabIndex: 0
        },
        cellCount > 0 && _react2.default.createElement(
          'div',
          {
            className: 'ReactVirtualized__Collection__innerScrollContainer',
            style: {
              height: totalHeight,
              maxHeight: totalHeight,
              maxWidth: totalWidth,
              overflow: 'hidden',
              pointerEvents: isScrolling ? 'none' : '',
              width: totalWidth
            }
          },
          childrenToDisplay
        ),
        cellCount === 0 && noContentRenderer()
      );
    }
  }, {
    key: 'shouldComponentUpdate',
    value: function shouldComponentUpdate(nextProps, nextState) {
      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);
    }

/* ---------------------------- Helper methods ---------------------------- */

/**
     * Sets an :isScrolling flag for a small window of time.
     * This flag is used to disable pointer events on the scrollable portion of the Collection.
     * This prevents jerky/stuttery mouse-wheel scrolling.
     */

}, {
    key: '_enablePointerEventsAfterDelay',
    value: function _enablePointerEventsAfterDelay() {
      var _this3 = this;

if (this._disablePointerEventsTimeoutId) {
        clearTimeout(this._disablePointerEventsTimeoutId);
      }

this._disablePointerEventsTimeoutId = setTimeout(function () {
        var isScrollingChange = _this3.props.isScrollingChange;

isScrollingChange(false);

_this3._disablePointerEventsTimeoutId = null;
        _this3.setState({
          isScrolling: false
        });
      }, IS_SCROLLING_TIMEOUT);
    }
  }, {
    key: '_invokeOnSectionRenderedHelper',
    value: function _invokeOnSectionRenderedHelper() {
      var _props4 = this.props;
      var cellLayoutManager = _props4.cellLayoutManager;
      var onSectionRendered = _props4.onSectionRendered;

this._onSectionRenderedMemoizer({
        callback: onSectionRendered,
        indices: {
          indices: cellLayoutManager.getLastRenderedIndices()
        }
      });
    }
  }, {
    key: '_invokeOnScrollMemoizer',
    value: function _invokeOnScrollMemoizer(_ref2) {
      var _this4 = this;

var scrollLeft = _ref2.scrollLeft;
      var scrollTop = _ref2.scrollTop;
      var totalHeight = _ref2.totalHeight;
      var totalWidth = _ref2.totalWidth;

this._onScrollMemoizer({
        callback: function callback(_ref3) {
          var scrollLeft = _ref3.scrollLeft;
          var scrollTop = _ref3.scrollTop;
          var _props5 = _this4.props;
          var height = _props5.height;
          var onScroll = _props5.onScroll;
          var width = _props5.width;

onScroll({
            clientHeight: height,
            clientWidth: width,
            scrollHeight: totalHeight,
            scrollLeft: scrollLeft,
            scrollTop: scrollTop,
            scrollWidth: totalWidth
          });
        },
        indices: {
          scrollLeft: scrollLeft,
          scrollTop: scrollTop
        }
      });
    }
  }, {
    key: '_setScrollPosition',
    value: function _setScrollPosition(_ref4) {
      var scrollLeft = _ref4.scrollLeft;
      var scrollTop = _ref4.scrollTop;

var newState = {
        scrollPositionChangeReason: SCROLL_POSITION_CHANGE_REASONS.REQUESTED
      };

if (scrollLeft >= 0) {
        newState.scrollLeft = scrollLeft;
      }

if (scrollTop >= 0) {
        newState.scrollTop = scrollTop;
      }

if (scrollLeft >= 0 && scrollLeft !== this.state.scrollLeft || scrollTop >= 0 && scrollTop !== this.state.scrollTop) {
        this.setState(newState);
      }
    }
  }, {
    key: '_updateScrollPositionForScrollToCell',
    value: function _updateScrollPositionForScrollToCell() {
      var _props6 = this.props;
      var cellLayoutManager = _props6.cellLayoutManager;
      var height = _props6.height;
      var scrollToAlignment = _props6.scrollToAlignment;
      var scrollToCell = _props6.scrollToCell;
      var width = _props6.width;
      var _state3 = this.state;
      var scrollLeft = _state3.scrollLeft;
      var scrollTop = _state3.scrollTop;

if (scrollToCell >= 0) {
        var scrollPosition = cellLayoutManager.getScrollPositionForCell({
          align: scrollToAlignment,
          cellIndex: scrollToCell,
          height: height,
          scrollLeft: scrollLeft,
          scrollTop: scrollTop,
          width: width
        });

if (scrollPosition.scrollLeft !== scrollLeft || scrollPosition.scrollTop !== scrollTop) {
          this._setScrollPosition(scrollPosition);
        }
      }
    }
  }, {
    key: '_onScroll',
    value: function _onScroll(event) {
      // In certain edge-cases React dispatches an onScroll event with an invalid target.scrollLeft / target.scrollTop.
      // This invalid event can be detected by comparing event.target to this component's scrollable DOM element.
      // See issue #404 for more information.
      if (event.target !== this._scrollingContainer) {
        return;
      }

// Prevent pointer events from interrupting a smooth scroll
      this._enablePointerEventsAfterDelay();

// When this component is shrunk drastically, React dispatches a series of back-to-back scroll events,
      // Gradually converging on a scrollTop that is within the bounds of the new, smaller height.
      // This causes a series of rapid renders that is slow for long lists.
      // We can avoid that by doing some simple bounds checking to ensure that scrollTop never exceeds the total height.
      var _props7 = this.props;
      var cellLayoutManager = _props7.cellLayoutManager;
      var height = _props7.height;
      var isScrollingChange = _props7.isScrollingChange;
      var width = _props7.width;

var scrollbarSize = this._scrollbarSize;

var _cellLayoutManager$ge3 = cellLayoutManager.getTotalSize();

var totalHeight = _cellLayoutManager$ge3.height;
      var totalWidth = _cellLayoutManager$ge3.width;

var scrollLeft = Math.max(0, Math.min(totalWidth - width + scrollbarSize, event.target.scrollLeft));
      var scrollTop = Math.max(0, Math.min(totalHeight - height + scrollbarSize, event.target.scrollTop));

// Certain devices (like Apple touchpad) rapid-fire duplicate events.
      // Don't force a re-render if this is the case.
      // The mouse may move faster then the animation frame does.
      // Use requestAnimationFrame to avoid over-updating.
      if (this.state.scrollLeft !== scrollLeft || this.state.scrollTop !== scrollTop) {
        // Browsers with cancelable scroll events (eg. Firefox) interrupt scrolling animations if scrollTop/scrollLeft is set.
        // Other browsers (eg. Safari) don't scroll as well without the help under certain conditions (DOM or style changes during scrolling).
        // All things considered, this seems to be the best current work around that I'm aware of.
        // For more information see https://github.com/bvaughn/react-virtualized/pull/124
        var scrollPositionChangeReason = event.cancelable ? SCROLL_POSITION_CHANGE_REASONS.OBSERVED : SCROLL_POSITION_CHANGE_REASONS.REQUESTED;

// Synchronously set :isScrolling the first time (since _setNextState will reschedule its animation frame each time it's called)
        if (!this.state.isScrolling) {
          isScrollingChange(true);
        }

this.setState({
          isScrolling: true,
          scrollLeft: scrollLeft,
          scrollPositionChangeReason: scrollPositionChangeReason,
          scrollTop: scrollTop
        });
      }

this._invokeOnScrollMemoizer({
        scrollLeft: scrollLeft,
        scrollTop: scrollTop,
        totalWidth: totalWidth,
        totalHeight: totalHeight
      });
    }
  }]);

return CollectionView;
}(_react.Component);

CollectionView.propTypes = {
  'aria-label': _react.PropTypes.string,

/**
   * Removes fixed height from the scrollingContainer so that the total height
   * of rows can stretch the window. Intended for use with WindowScroller
   */
  autoHeight: _react.PropTypes.bool,

/**
   * Number of cells in collection.
   */
  cellCount: _react.PropTypes.number.isRequired,

/**
   * Calculates cell sizes and positions and manages rendering the appropriate cells given a specified window.
   */
  cellLayoutManager: _react.PropTypes.object.isRequired,

/**
   * Optional custom CSS class name to attach to root Collection element.
   */
  className: _react.PropTypes.string,

/**
   * Height of Collection; this property determines the number of visible (vs virtualized) rows.
   */
  height: _react.PropTypes.number.isRequired,

/**
   * Enables the `Collection` to horiontally "overscan" its content similar to how `Grid` does.
   * This can reduce flicker around the edges when a user scrolls quickly.
   */
  horizontalOverscanSize: _react.PropTypes.number.isRequired,

isScrollingChange: _react.PropTypes.func,

/**
   * Optional renderer to be used in place of rows when either :rowCount or :cellCount is 0.
   */
  noContentRenderer: _react.PropTypes.func.isRequired,

/**
   * Callback invoked with information about the section of the Collection that was just rendered.
   * This callback is passed a named :indices parameter which is an Array of the most recently rendered section indices.
   */
  onSectionRendered: _react.PropTypes.func.isRequired,

/**
   * Horizontal offset.
   */
  scrollLeft: _react.PropTypes.number,

/**
   * Controls scroll-to-cell behavior of the Grid.
   * The default ("auto") scrolls the least amount possible to ensure that the specified cell is fully visible.
   * Use "start" to align cells to the top/left of the Grid and "end" to align bottom/right.
   */
  scrollToAlignment: _react.PropTypes.oneOf(['auto', 'end', 'start', 'center']).isRequired,

/**
   * Cell index to ensure visible (by forcefully scrolling if necessary).
   */
  scrollToCell: _react.PropTypes.number,

/**
   * Vertical offset.
   */
  scrollTop: _react.PropTypes.number,

/**
   * Optional custom inline style to attach to root Collection element.
   */
  style: _react.PropTypes.object,

/**
   * Enables the `Collection` to vertically "overscan" its content similar to how `Grid` does.
   * This can reduce flicker around the edges when a user scrolls quickly.
   */
  verticalOverscanSize: _react.PropTypes.number.isRequired,

/**
   * Width of Collection; this property determines the number of visible (vs virtualized) columns.
   */
  width: _react.PropTypes.number.isRequired
};
CollectionView.defaultProps = {
  'aria-label': 'grid',
  horizontalOverscanSize: 0,
  noContentRenderer: function noContentRenderer() {
    return null;
  },
  onScroll: function onScroll() {
    return null;
  },
  onSectionRendered: function onSectionRendered() {
    return null;
  },
  scrollToAlignment: 'auto',
  style: {},
  verticalOverscanSize: 0
};
exports.default = CollectionView;

/***/ }),
/* 1326 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * A section of the Window.
 * Window Sections are used to group nearby cells.
 * This enables us to more quickly determine which cells to display in a given region of the Window.
 * Sections have a fixed size and contain 0 to many cells (tracked by their indices).
 */
var Section = function () {
  function Section(_ref) {
    var height = _ref.height;
    var width = _ref.width;
    var x = _ref.x;
    var y = _ref.y;

_classCallCheck(this, Section);

this.height = height;
    this.width = width;
    this.x = x;
    this.y = y;

this._indexMap = {};
    this._indices = [];
  }

/** Add a cell to this section. */

_createClass(Section, [{
    key: 'addCellIndex',
    value: function addCellIndex(_ref2) {
      var index = _ref2.index;

if (!this._indexMap[index]) {
        this._indexMap[index] = true;
        this._indices.push(index);
      }
    }

/** Get all cell indices that have been added to this section. */

}, {
    key: 'getCellIndices',
    value: function getCellIndices() {
      return this._indices;
    }

/** Intended for debugger/test purposes only */

}, {
    key: 'toString',
    value: function toString() {
      return this.x + ',' + this.y + ' ' + this.width + 'x' + this.height;
    }
  }]);

return Section;
}(); /** @rlow */

exports.default = Section;

/***/ }),
/* 1327 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _Section = __webpack_require__(1326);

var _Section2 = _interopRequireDefault(_Section);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var SECTION_SIZE = 100;

/**
 * Contains 0 to many Sections.
 * Grows (and adds Sections) dynamically as cells are registered.
 * Automatically adds cells to the appropriate Section(s).
 */
var SectionManager = function () {
  function SectionManager() {
    var sectionSize = arguments.length <= 0 || arguments[0] === undefined ? SECTION_SIZE : arguments[0];

_classCallCheck(this, SectionManager);

this._sectionSize = sectionSize;

this._cellMetadata = [];
    this._sections = {};
  }

/**
   * Gets all cell indices contained in the specified region.
   * A region may encompass 1 or more Sections.
   */

_createClass(SectionManager, [{
    key: 'getCellIndices',
    value: function getCellIndices(_ref) {
      var height = _ref.height;
      var width = _ref.width;
      var x = _ref.x;
      var y = _ref.y;

var indices = {};

this.getSections({ height: height, width: width, x: x, y: y }).forEach(function (section) {
        return section.getCellIndices().forEach(function (index) {
          indices[index] = index;
        });
      });

// Object keys are strings; this function returns numbers
      return Object.keys(indices).map(function (index) {
        return indices[index];
      });
    }

/** Get size and position information for the cell specified. */

}, {
    key: 'getCellMetadata',
    value: function getCellMetadata(_ref2) {
      var index = _ref2.index;

return this._cellMetadata[index];
    }

/** Get all Sections overlapping the specified region. */

}, {
    key: 'getSections',
    value: function getSections(_ref3) {
      var height = _ref3.height;
      var width = _ref3.width;
      var x = _ref3.x;
      var y = _ref3.y;

var sectionXStart = Math.floor(x / this._sectionSize);
      var sectionXStop = Math.floor((x + width - 1) / this._sectionSize);
      var sectionYStart = Math.floor(y / this._sectionSize);
      var sectionYStop = Math.floor((y + height - 1) / this._sectionSize);

var sections = [];

for (var sectionX = sectionXStart; sectionX <= sectionXStop; sectionX++) {
        for (var sectionY = sectionYStart; sectionY <= sectionYStop; sectionY++) {
          var key = sectionX + '.' + sectionY;

if (!this._sections[key]) {
            this._sections[key] = new _Section2.default({
              height: this._sectionSize,
              width: this._sectionSize,
              x: sectionX * this._sectionSize,
              y: sectionY * this._sectionSize
            });
          }

sections.push(this._sections[key]);
        }
      }

return sections;
    }

/** Total number of Sections based on the currently registered cells. */

}, {
    key: 'getTotalSectionCount',
    value: function getTotalSectionCount() {
      return Object.keys(this._sections).length;
    }

/** Intended for debugger/test purposes only */

}, {
    key: 'toString',
    value: function toString() {
      var _this = this;

return Object.keys(this._sections).map(function (index) {
        return _this._sections[index].toString();
      });
    }

/** Adds a cell to the appropriate Sections and registers it metadata for later retrievable. */

}, {
    key: 'registerCell',
    value: function registerCell(_ref4) {
      var cellMetadatum = _ref4.cellMetadatum;
      var index = _ref4.index;

this._cellMetadata[index] = cellMetadatum;

this.getSections(cellMetadatum).forEach(function (section) {
        return section.addCellIndex({ index: index });
      });
    }
  }]);

return SectionManager;
}();

exports.default = SectionManager;

/***/ }),
/* 1328 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Collection = exports.default = undefined;

var _Collection2 = __webpack_require__(1324);

var _Collection3 = _interopRequireDefault(_Collection2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _Collection3.default;
exports.Collection = _Collection3.default;

/***/ }),
/* 1329 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = calculateSizeAndPositionData;

var _SectionManager = __webpack_require__(1327);

var _SectionManager2 = _interopRequireDefault(_SectionManager);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function calculateSizeAndPositionData(_ref) {
  var cellCount = _ref.cellCount;
  var cellSizeAndPositionGetter = _ref.cellSizeAndPositionGetter;
  var sectionSize = _ref.sectionSize;

var cellMetadata = [];
  var sectionManager = new _SectionManager2.default(sectionSize);
  var height = 0;
  var width = 0;

for (var index = 0; index < cellCount; index++) {
    var cellMetadatum = cellSizeAndPositionGetter({ index: index });

if (cellMetadatum.height == null || isNaN(cellMetadatum.height) || cellMetadatum.width == null || isNaN(cellMetadatum.width) || cellMetadatum.x == null || isNaN(cellMetadatum.x) || cellMetadatum.y == null || isNaN(cellMetadatum.y)) {
      throw Error('Invalid metadata returned for cell ' + index + ':\n        x:' + cellMetadatum.x + ', y:' + cellMetadatum.y + ', width:' + cellMetadatum.width + ', height:' + cellMetadatum.height);
    }

height = Math.max(height, cellMetadatum.y + cellMetadatum.height);
    width = Math.max(width, cellMetadatum.x + cellMetadatum.width);

cellMetadata[index] = cellMetadatum;
    sectionManager.registerCell({
      cellMetadatum: cellMetadatum,
      index: index
    });
  }

return {
    cellMetadata: cellMetadata,
    height: height,
    sectionManager: sectionManager,
    width: width
  };
}

/***/ }),
/* 1330 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _react = __webpack_require__(0);

var _reactAddonsShallowCompare = __webpack_require__(36);

var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);

var _Grid = __webpack_require__(191);

var _Grid2 = _interopRequireDefault(_Grid);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * High-order component that auto-calculates column-widths for `Grid` cells.
 */
var ColumnSizer = function (_Component) {
  _inherits(ColumnSizer, _Component);

function ColumnSizer(props, context) {
    _classCallCheck(this, ColumnSizer);

var _this = _possibleConstructorReturn(this, (ColumnSizer.__proto__ || Object.getPrototypeOf(ColumnSizer)).call(this, props, context));

_this._registerChild = _this._registerChild.bind(_this);
    return _this;
  }

_createClass(ColumnSizer, [{
    key: 'componentDidUpdate',
    value: function componentDidUpdate(prevProps, prevState) {
      var _props = this.props;
      var columnMaxWidth = _props.columnMaxWidth;
      var columnMinWidth = _props.columnMinWidth;
      var columnCount = _props.columnCount;
      var width = _props.width;

if (columnMaxWidth !== prevProps.columnMaxWidth || columnMinWidth !== prevProps.columnMinWidth || columnCount !== prevProps.columnCount || width !== prevProps.width) {
        if (this._registeredChild) {
          this._registeredChild.recomputeGridSize();
        }
      }
    }
  }, {
    key: 'render',
    value: function render() {
      var _props2 = this.props;
      var children = _props2.children;
      var columnMaxWidth = _props2.columnMaxWidth;
      var columnMinWidth = _props2.columnMinWidth;
      var columnCount = _props2.columnCount;
      var width = _props2.width;

var safeColumnMinWidth = columnMinWidth || 1;

var safeColumnMaxWidth = columnMaxWidth ? Math.min(columnMaxWidth, width) : width;

var columnWidth = width / columnCount;
      columnWidth = Math.max(safeColumnMinWidth, columnWidth);
      columnWidth = Math.min(safeColumnMaxWidth, columnWidth);
      columnWidth = Math.floor(columnWidth);

var adjustedWidth = Math.min(width, columnWidth * columnCount);

return children({
        adjustedWidth: adjustedWidth,
        getColumnWidth: function getColumnWidth() {
          return columnWidth;
        },
        registerChild: this._registerChild
      });
    }
  }, {
    key: 'shouldComponentUpdate',
    value: function shouldComponentUpdate(nextProps, nextState) {
      return (0, _reactAddonsShallowCompare2.default)(this, nextProps, nextState);
    }
  }, {
    key: '_registerChild',
    value: function _registerChild(child) {
      if (child !== null && !(child instanceof _Grid2.default)) {
        throw Error('Unexpected child type registered; only Grid children are supported.');
      }

this._registeredChild = child;

if (this._registeredChild) {
        this._registeredChild.recomputeGridSize();
      }
    }
  }]);

return ColumnSizer;
}(_react.Component);

ColumnSizer.propTypes = {
  /**
   * Function responsible for rendering a virtualized Grid.
   * This function should implement the following signature:
   * ({ adjustedWidth, getColumnWidth, registerChild }) => PropTypes.element
   *
   * The specified :getColumnWidth function should be passed to the Grid's :columnWidth property.
   * The :registerChild should be passed to the Grid's :ref property.
   * The :adjustedWidth property is optional; it reflects the lesser of the overall width or the width of all columns.
   */
  children: _react.PropTypes.func.isRequired,

/** Optional maximum allowed column width */
  columnMaxWidth: _react.PropTypes.number,

/** Optional minimum allowed column width */
  columnMinWidth: _react.PropTypes.number,

/** Number of columns in Grid or Table child */
  columnCount: _react.PropTypes.number.isRequired,

/** Width of Grid or Table child */
  width: _react.PropTypes.number.isRequired
};
exports.default = ColumnSizer;

/***/ }),
/* 1331 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ColumnSizer = exports.default = undefined;

var _ColumnSizer2 = __webpack_require__(1330);

var _ColumnSizer3 = _interopRequireDefault(_ColumnSizer2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.default = _ColumnSizer3.default;
exports.ColumnSizer = _ColumnSizer3.default;

/***/ }),
/* 1332 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DEFAULT_SCROLLING_RESET_TIME_INTERVAL = undefined;

var _react = __webpack_require__(0);

var _react2 = _interopRequireDefault(_react);

var _classnames = __webpack_require__(9);

var _classnames2 = _interopRequireDefault(_classnames);

var _calculateSizeAndPositionDataAndUpdateScrollOffset = __webpack_require__(1335);

var _calculateSizeAndPositionDataAndUpdateScrollOffset2 = _interopRequireDefault(_calculateSizeAndPositionDataAndUpdateScrollOffset);

var _ScalingCellSizeAndPositionManager = __webpack_require__(1334);

var _ScalingCellSizeAndPositionManager2 = _interopRequireDefault(_ScalingCellSizeAndPositionManager);

var _createCallbackMemoizer = __webpack_require__(315);

var _createCallbackMemoizer2 = _interopRequireDefault(_createCallbackMemoizer);

var _getOverscanIndices = __webpack_require__(1336);

var _getOverscanIndices2 = _interopRequireDefault(_getOverscanIndices);

var _scrollbarSize = __webpack_require__(316);

var _scrollbarSize2 = _interopRequireDefault(_scrollbarSize);

var _reactAddonsShallowCompare = __webpack_require__(36);

var _reactAddonsShallowCompare2 = _interopRequireDefault(_reactAddonsShallowCompare);

var _updateScrollIndexHelper = __webpack_require__(1337);

var _updateScrollIndexHelper2 = _interopRequireDefault(_updateScrollIndexHelper);

var _defaultCellRangeRenderer = __webpack_require__(509);

var _defaultCellRangeRenderer2 = _interopRequireDefault(_defaultCellRangeRenderer);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Renders tabular data with virtualization along the vertical and horizontal axes.
 * Row heights and column widths must be known ahead of time and specified as properties.
 */

var Grid = function (_Component) {
  _inherits(Grid, _Component);

function Grid(props, context) {
    _classCallCheck(this, Grid);

var _this = _possibleConstructorReturn(this, (Grid.__proto__ || Object.getPrototypeOf(Grid)).call(this, props, context));

_this.state = {
      isScrolling: false,
      scrollDirectionHorizontal: _getOverscanIndices.SCROLL_DIRECTION_FIXED,
      scrollDirectionVertical: _getOverscanIndices.SCROLL_DIRECTION_FIXED,
      scrollLeft: 0,
      scrollTop: 0
    };

// Invokes onSectionRendered callback only when start/stop row or column indices change
    _this._onGridRenderedMemoizer = (0, _createCallbackMemoizer2.default)();
    _this._onScrollMemoizer = (0, _createCallbackMemoizer2.default)(false);

_this._columnWidthGetter = _this._wrapSizeGetter(props.columnWidth);
    _this._rowHeightGetter = _this._wrapSizeGetter(props.rowHeight);

_this._columnSizeAndPositionManager = new _ScalingCellSizeAndPositionManager2.default({
      cellCount: props.columnCount,
      cellSizeGetter: function cellSizeGetter(index) {
        return _this._columnWidthGetter(index);
      },
      estimatedCellSize: _this._getEstimatedColumnSize(props)
    });
    _this._rowSizeAndPositionManager = new _ScalingCellSizeAndPositionManager2.default({
      cellCount: props.rowCount,
      cellSizeGetter: function cellSizeGetter(index) {
        return _this._rowHeightGetter(index);
      },
      estimatedCellSize: _this._getEstimatedRowSize(props)
    });

// See defaultCellRangeRenderer() for more information on the usage of this cache
    _this._cellCache = {};
    return _this;
  }

_createClass(Grid, [{
    key: 'measureAllCells',
    value: function measureAllCells() {
      var _props = this.props;
      var columnCount = _props.columnCount;
      var rowCount = _props.rowCount;